if False:
    from typing import Dict, List, Tuple, Union, Optional

class AELoader(type):
    """
    Metaclass used by `AETemplate` class to create wrapping and loading
    mechanisms when an AETemplate instance is created
    """
    
    
    
    @classmethod
    def loadedTemplates(cls):
        """
        Return the names of the loaded templates
        """
        pass
    @staticmethod
    def __new__(cls, classname, bases, classdict): pass
    @staticmethod
    def load(modname, classname, nodename): pass
    @staticmethod
    def makeAEProc(modname, classname, procname): pass


class UITemplate(object):
    """
    from pymel.core import *
    
    # force deletes the template if it already exists
    template = ui.UITemplate( 'ExampleTemplate', force=True )
    
    template.define( button, width=100, height=40, align='left' )
    template.define( frameLayout, borderVisible=True, labelVisible=False )
    
    #    Create a window and apply the template.
    #
    with window():
        with template:
            with columnLayout( rowSpacing=5 ):
                with frameLayout():
                    with columnLayout():
                        button( label='One' )
                        button( label='Two' )
                        button( label='Three' )
    
                with frameLayout():
                    with columnLayout():
                        button( label='Red' )
                        button( label='Green' )
                        button( label='Blue' )
    """
    
    
    
    def __enter__(self): pass
    def __exit__(self, type, value, traceback): pass
    def __init__(self, name='None', force='False'): pass
    def __repr__(self): pass
    def define(self, uiType, **kwargs):
        """
        uiType can be:
            - a ui function or class
            - the name of a ui function or class
            - a list or tuple of the above
        """
        pass
    def name(self): pass
    def pop(self): pass
    def push(self): pass
    @staticmethod
    def exists(name): pass
    __dict__ = None
    
    
    __weakref__ = None


class AETemplate(object):
    """
    To create an Attribute Editor template using python, do the following:
         1. create a subclass of `uitypes.AETemplate`
        2. set its ``_nodeType`` class attribute to the name of the desired node type, or name the class using the
    convention ``AE<nodeType>Template``
        3. import the module
    
    AETemplates which do not meet one of the two requirements listed in step 2 will be ignored.  To ensure that your
    Template's node type is being detected correctly, use the ``AETemplate.nodeType()`` class method::
    
        import AETemplates
        AETemplates.AEmib_amb_occlusionTemplate.nodeType()
    
    As a convenience, when pymel is imported it will automatically import the module ``AETemplates``, if it exists,
    thereby causing any AETemplates within it or its sub-modules to be registered. Be sure to import pymel
    or modules containing your ``AETemplate`` classes before opening the Atrribute Editor for the node types in question.
    
    To check which python templates are loaded::
    
        from pymel.core.uitypes import AELoader
        print AELoader.loadedTemplates()
    """
    
    
    
    def __init__(self, nodeName): pass
    def addComponents(self): pass
    def addControl(self, control, label='None', changeCommand='None', annotation='None', preventOverride='False', dynamic='False'): pass
    def addExtraControls(self, label='None'): pass
    def addSeparator(self): pass
    def beginLayout(self, name, collapse='True'): pass
    def beginNoOptimize(self): pass
    def beginScrollLayout(self): pass
    def callCustom(self, newFunc, replaceFunc, *attrs): pass
    def dimControl(self, nodeName, control, state): pass
    def endLayout(self): pass
    def endNoOptimize(self): pass
    def endScrollLayout(self): pass
    def interruptOptimize(self): pass
    def suppress(self, control): pass
    @classmethod
    def controlLabel(cls, nodeName, control): pass
    @classmethod
    def controlValue(cls, nodeName, control): pass
    @classmethod
    def nodeType(cls): pass
    @classmethod
    def reload(cls):
        """
        Reload the template. Beware, this reloads the module in which the template exists!
        """
        pass
    @property
    def nodeName(self): pass
    __dict__ = None
    
    
    
    
    __weakref__ = None


class PyUI(str):
    def __repr__(self): pass
    def asQtObject(mayaName):
        """
        Given the name of a May UI control, return the corresponding QWidget.
        If the object does not exist, returns None
        
        .. note:: Requires PySide
        """
        pass
    def delete(*args, **kwargs):
        """
        This command deletes UI objects such as windows and controls.  Deleting a layout
        or window will also delete all of its children.  If a flag is used then all
        objects being deleted must be of the specified type. This command may not be
        edited or queried. NOTE: it is recommended that the type flags be used to
        disambiguate different kinds of objects with the same name.
        
        This command deletes UI objects such as windows and controls.  Deleting a layout
        or window will also delete all of its children.  If a flag is used then all
        objects being deleted must be of the specified type. This command may not be
        edited or queried. NOTE: it is recommended that the type flags be used to
        disambiguate different kinds of objects with the same name.
        
        Flags:
        - collection : cl                (bool)          [create]
            Object names for deletion are all radio or tool collections.
        
        - control : ctl                  (bool)          [create]
            Object names for deletion are all controls.
        
        - editor : ed                    (bool)          [create]
            Object names for deletion are all editors.
        
        - layout : lay                   (bool)          [create]
            Object names for deletion are all layouts.
        
        - menu : m                       (bool)          [create]
            Object names for deletion are all menus.
        
        - menuItem : mi                  (bool)          [create]
            Object names for deletion are all menu items.
        
        - panel : pnl                    (bool)          [create]
            Object names for deletion are all panels.
        
        - panelConfig : pc               (bool)          [create]
            Object names for deletion are panel configurations.
        
        - radioMenuItemCollection : ric  (bool)          [create]
            Object names for deletion are all radio menu item collections.
        
        - toolContext : tc               (bool)          [create]
            Object names for deletion are all tool contexts.
        
        - uiTemplate : uit               (bool)          [create]
            Object names for deletion are all UI templates.
        
        - window : wnd                   (bool)          [create]
            Object names for deletion are all windows.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.deleteUI`
        
        Flags:
        - collection : cl                (bool)          [create]
            Object names for deletion are all radio or tool collections.
        
        - control : ctl                  (bool)          [create]
            Object names for deletion are all controls.
        
        - editor : ed                    (bool)          [create]
            Object names for deletion are all editors.
        
        - layout : lay                   (bool)          [create]
            Object names for deletion are all layouts.
        
        - menu : m                       (bool)          [create]
            Object names for deletion are all menus.
        
        - menuItem : mi                  (bool)          [create]
            Object names for deletion are all menu items.
        
        - panel : pnl                    (bool)          [create]
            Object names for deletion are all panels.
        
        - panelConfig : pc               (bool)          [create]
            Object names for deletion are panel configurations.
        
        - radioMenuItemCollection : ric  (bool)          [create]
            Object names for deletion are all radio menu item collections.
        
        - toolContext : tc               (bool)          [create]
            Object names for deletion are all tool contexts.
        
        - uiTemplate : uit               (bool)          [create]
            Object names for deletion are all UI templates.
        
        - window : wnd                   (bool)          [create]
            Object names for deletion are all windows.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.deleteUI`
        """
        pass
    def getParent(self):
        """
        Returns
        -------
        PyUI
        """
        pass
    def name(self):
        """
        Returns
        -------
        unicode
        """
        pass
    def parent(self):
        """
        Returns
        -------
        PyUI
        """
        pass
    def rename(*args, **kwargs):
        """
        This command renames the UI object passed as first arument to the new name
        specified as second argument. If the new name is a duplicate, or not valid, then
        re-naming fails and the old name is returned.
        
        This command renames the UI object passed as first arument to the new name
        specified as second argument. If the new name is a duplicate, or not valid, then
        re-naming fails and the old name is returned.
        
        
        Derived from mel command `maya.cmds.renameUI`
        
        
        Derived from mel command `maya.cmds.renameUI`
        """
        pass
    def shortName(self):
        """
        Returns
        -------
        unicode
        """
        pass
    def type(name, **kwargs):
        """
        This command returns the type of UI element such as button, sliders, etc.
        
        Flags:
        - isType : i                     (unicode)       [create]
            Returns true|false if the object is of the specified type.
        
        - listAll : la                   (bool)          [create]
            Returns a list of all known UI commands and their respective types. Each entry
            contains three strings which are the command name, ui type and class name. Note
            that the class name is internal and is subject to change.
        
        - superClasses : sc              (bool)          [create]
            Returns a list of the names of all super classes for the given object. Note that
            all class names are internal and are subject to change.                  Flag
            can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.objectTypeUI`
        """
        pass
    def window(self):
        """
        Returns
        -------
        Window
        """
        pass
    @classmethod
    def exists(cls, name): pass
    @staticmethod
    def __new__(cls, name='None', create='False', **kwargs):
        """
        Provides the ability to create the PyUI Element when creating a class::
        
            import pymel.core as pm
            n = pm.Window("myWindow",create=True)
            n.__repr__()
            # Result: Window('myWindow')
        """
        pass
    __dict__ = None
    
    
    __melui__ = None
    
    
    __weakref__ = None


class ScriptedPanelType(PyUI):
    def getAddCallback(self, **kwargs):
        """
        This flag specifies the callback procedure for adding the panel to a particular control layout.  The parent layout is guaranteed to be the current default layout when the proc is called.  If its name is required then it can be queried with 'setParent -q'.  Any editors should be parented here. global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getCopyStateCallback(self, **kwargs):
        """
        This flag specifies the callback procedure for copying the state of the panel when a tear-off copy of the panel is made.  The callback proc has the form: global proc procName (string $panelName, string $newPanelName) { .... } This procedure will be executed immediately after the addCallback procedure has finished executing. At that point, the copied panel will be fully created and accessible to facilitate copying of panel settings. Note: the addCallback procedure is called after the createCallback procedure has been called.                   
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getCreateCallback(self, **kwargs):
        """
        This flag specifies the callback procedure for initially creating the panel object.  No UI should be created here.  Any editors owned by the panel should be created here unparented. The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getCustomView(self, **kwargs):
        """
        This flag specifies if this view is a custom 3d view for MPx3dModelView types. This flag should only be used for MPx3dModelView types.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getDeleteCallback(self, **kwargs):
        """
        This flag specifies the callback procedure for final deletion of the panel.  The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getHotkeyCtxClient(self, **kwargs):
        """
        This flag is used to specify the name of the hotkey context client for this panel type. By default, it is the same as the panel type.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getInitCallback(self, **kwargs):
        """
        This flag specifies the callback procedure for the initialize callback.  This will be called on file -new and file -open to give the panel an opportunity to re-initialize to a starting state, if required. The panel may be parented or unparented at this time. The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label for the panel                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getObsolete(self, **kwargs):
        """
        This flag specifies that this type is no longer used in Maya.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getRemoveCallback(self, **kwargs):
        """
        This flag specifies the callback procedure for removing the panel from its current control layout.  Any editors should be unparented here. The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getRetainOnFileOpen(self, **kwargs):
        """
        This flag specifies if panels of this type should be retained after restoring panel cofiguration during file open. Default value is false.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getSaveStateCallback(self, **kwargs):
        """
        This flag specifies the callback procedure for saving the state of the panel.  The callback proc has the form: global proc string procName (string $panelName) { .... } Note that the proc returns a string.  This string will be executed after the createCallback has been called to facilitate restoring the panel state.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def getUnique(self, **kwargs):
        """
        This flag specifies if only one instance of this type of panel can exist at a given time.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setAddCallback(self, val='True', **kwargs):
        """
        This flag specifies the callback procedure for adding the panel to a particular control layout.  The parent layout is guaranteed to be the current default layout when the proc is called.  If its name is required then it can be queried with 'setParent -q'.  Any editors should be parented here. global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setCopyStateCallback(self, val='True', **kwargs):
        """
        This flag specifies the callback procedure for copying the state of the panel when a tear-off copy of the panel is made.  The callback proc has the form: global proc procName (string $panelName, string $newPanelName) { .... } This procedure will be executed immediately after the addCallback procedure has finished executing. At that point, the copied panel will be fully created and accessible to facilitate copying of panel settings. Note: the addCallback procedure is called after the createCallback procedure has been called.                   
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setCreateCallback(self, val='True', **kwargs):
        """
        This flag specifies the callback procedure for initially creating the panel object.  No UI should be created here.  Any editors owned by the panel should be created here unparented. The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setCustomView(self, val='True', **kwargs):
        """
        This flag specifies if this view is a custom 3d view for MPx3dModelView types. This flag should only be used for MPx3dModelView types.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setDeleteCallback(self, val='True', **kwargs):
        """
        This flag specifies the callback procedure for final deletion of the panel.  The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setHotkeyCtxClient(self, val='True', **kwargs):
        """
        This flag is used to specify the name of the hotkey context client for this panel type. By default, it is the same as the panel type.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setInitCallback(self, val='True', **kwargs):
        """
        This flag specifies the callback procedure for the initialize callback.  This will be called on file -new and file -open to give the panel an opportunity to re-initialize to a starting state, if required. The panel may be parented or unparented at this time. The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label for the panel                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setObsolete(self, val='True', **kwargs):
        """
        This flag specifies that this type is no longer used in Maya.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setRemoveCallback(self, val='True', **kwargs):
        """
        This flag specifies the callback procedure for removing the panel from its current control layout.  Any editors should be unparented here. The callback proc has the form: global proc procName (string $panelName) { .... }                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setRetainOnFileOpen(self, val='True', **kwargs):
        """
        This flag specifies if panels of this type should be retained after restoring panel cofiguration during file open. Default value is false.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setSaveStateCallback(self, val='True', **kwargs):
        """
        This flag specifies the callback procedure for saving the state of the panel.  The callback proc has the form: global proc string procName (string $panelName) { .... } Note that the proc returns a string.  This string will be executed after the createCallback has been called to facilitate restoring the panel state.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    def setUnique(self, val='True', **kwargs):
        """
        This flag specifies if only one instance of this type of panel can exist at a given time.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command defines the callbacks for a type of scripted panel.  The panel type
        created by this command is then used when creating a scripted panel.  See also
        the 'scriptedPanel' command.
        
        Flags:
        - addCallback : acb              (unicode)       [create,query,edit]
            This flag specifies the callback procedure for adding the panel to a particular
            control layout.  The parent layout is guaranteed to be the current default
            layout when the proc is called.  If its name is required then it can be queried
            with 'setParent -q'.  Any editors should be parented here. global proc procName
            (string $panelName) { .... }
        
        - copyStateCallback : ocb        (unicode)       [create,query,edit]
            This flag specifies the callback procedure for copying the state of the panel
            when a tear-off copy of the panel is made.  The callback proc has the form:
            global proc procName (string $panelName, string $newPanelName) { .... } This
            procedure will be executed immediately after the addCallback procedure has
            finished executing. At that point, the copied panel will be fully created and
            accessible to facilitate copying of panel settings. Note: the addCallback
            procedure is called after the createCallback procedure has been called.
        
        - createCallback : ccb           (unicode)       [create,query,edit]
            This flag specifies the callback procedure for initially creating the panel
            object.  No UI should be created here.  Any editors owned by the panel should be
            created here unparented. The callback proc has the form: global proc procName
            (string $panelName) { .... }
        
        - customView : cv                (bool)          [create,query,edit]
            This flag specifies if this view is a custom 3d view for MPx3dModelView types.
            This flag should only be used for MPx3dModelView types.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteCallback : dcb           (unicode)       [create,query,edit]
            This flag specifies the callback procedure for final deletion of the panel.  The
            callback proc has the form: global proc procName (string $panelName) { .... }
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - hotkeyCtxClient : hkc          (unicode)       [create,query,edit]
            This flag is used to specify the name of the hotkey context client for this
            panel type. By default, it is the same as the panel type.
        
        - initCallback : icb             (unicode)       [create,query,edit]
            This flag specifies the callback procedure for the initialize callback.  This
            will be called on file -new and file -open to give the panel an opportunity to
            re-initialize to a starting state, if required. The panel may be parented or
            unparented at this time. The callback proc has the form: global proc procName
            (string $panelName) { .... }
        
        - label : l                      (unicode)       [create,query,edit]
            Label for the panel
        
        - obsolete : o                   (bool)          [create,query,edit]
            This flag specifies that this type is no longer used in Maya.
        
        - removeCallback : rcb           (unicode)       [create,query,edit]
            This flag specifies the callback procedure for removing the panel from its
            current control layout.  Any editors should be unparented here. The callback
            proc has the form: global proc procName (string $panelName) { .... }
        
        - retainOnFileOpen : rfo         (bool)          [create,query,edit]
            This flag specifies if panels of this type should be retained after restoring
            panel cofiguration during file open. Default value is false.
        
        - saveStateCallback : scb        (unicode)       [create,query,edit]
            This flag specifies the callback procedure for saving the state of the panel.
            The callback proc has the form: global proc string procName (string $panelName)
            { .... } Note that the proc returns a string.  This string will be executed
            after the createCallback has been called to facilitate restoring the panel
            state.
        
        - unique : u                     (bool)          [create,query,edit]
            This flag specifies if only one instance of this type of panel can exist at a
            given time.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.scriptedPanelType`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'scriptedPanelType'
    
    
    __melui__ = 'scriptedPanelType'


class FloatScrollBar(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes.  This command is not invoked when the value changes via the -v/value flag.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes by dragging the scroll bar's value marker.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getHorizontal(self, **kwargs):
        """
        Orientation of the slider.  This flag is true by default, which corresponds to a horizontally oriented slider.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getLargeStep(self, **kwargs):
        """
        Larger increment for the scroll bar, ie. the increment used when the press is between the arrow button and the thumb.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Upper limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Lower limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getStep(self, **kwargs):
        """
        Smaller increment for the scroll bar, ie. the increment used when the arrow buttons are pressed.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setLargeStep(self, val='True', **kwargs):
        """
        Larger increment for the scroll bar, ie. the increment used when the press is between the arrow button and the thumb.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Upper limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Lower limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Smaller increment for the scroll bar, ie. the increment used when the arrow buttons are pressed.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a scroll bar control that accepts only float values and is bound by a
        minimum and maximum value.  The scroll bar displays a marker indicating the
        current value of the scroll bar relative to its minimum and maximum values.
        Click and drag the marker or on the scroll bar itself to change the current
        value.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the value changes.  This command is not invoked when the
            value changes via the -v/value flag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command executed when the value changes by dragging the scroll bar's value
            marker.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontal : hr                (bool)          [create,query]
            Orientation of the slider.  This flag is true by default, which corresponds to a
            horizontally oriented slider.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - largeStep : ls                 (float)         [create,query,edit]
            Larger increment for the scroll bar, ie. the increment used when the press is
            between the arrow button and the thumb.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (float)         [create,query,edit]
            Upper limit of the scroll bar.
        
        - minValue : min                 (float)         [create,query,edit]
            Lower limit of the scroll bar.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            Smaller increment for the scroll bar, ie. the increment used when the arrow
            buttons are pressed.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (float)         [create,query,edit]
            Value of the scroll bar.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.floatScrollBar`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'floatScrollBar'
    
    
    __melui__ = 'floatScrollBar'


class CmdScrollFieldExecuter(PyUI):
    def appendText(self, val='True', **kwargs):
        """
        Appends text to the end of this field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def clear(self, val='True', **kwargs):
        """
        Clears the field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def copySelection(self, val='True', **kwargs):
        """
        Copies the current selection from this field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def cutSelection(self, val='True', **kwargs):
        """
        Cuts the current selection from this field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def execute(self, val='True', **kwargs):
        """
        Executes the current selection.  If there is no selection, all text is executed.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def executeAll(self, val='True', **kwargs):
        """
        Executes all text.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def fileChangedCommand(self, val='True', **kwargs):
        """
        Only valid when this field contains a file. Sets a script which will be called whenever the file is externally modified, renamed or removed from disk. In MEL, the function should have the following signature: proc fileChanged(string $file)
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getAutoCloseBraces(self, **kwargs):
        """
        Specifies whether a closing brace should automatically be added when hitting enter after an opening brace. (default on)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getCommandCompletion(self, **kwargs):
        """
        Enable/disable command completion                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getCurrentLine(self, **kwargs):
        """
        Sets/returns the current line which the cursor is on.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getFilename(self, **kwargs):
        """
        Returns the full path + filename of the script which was either loaded or saved. If there isn't one returns an empty string.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getFilterKeyPress(self, **kwargs):
        """
        Sets a script which will be called to handle key-press events. The function should have the following signature: proc int filterKeyPress(int $modifiers, string $key)modifiers: a bit mask where Shift is bit 1, Ctrl is bit 3, Alt is bit 4, and bit 5 is the 'Windows' key on Windows keyboards and the Command key on Mac keyboards. key: Specifies what key was pressed. The key is either a single ascii character or one of the keyword strings for the special keyboard characters. For example: Up, Down, Right, Left, Home, End, Page_Up, Page_Down, Insert Return, Space F1 to F12 The function should return 1 to indicate that they key event has been handled, and 0 to indicate that it has not been handled.                   
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getHasFocus(self, **kwargs):
        """
        Whether this control is currently in focus.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getHasSelection(self, **kwargs):
        """
        Whether this control currently has a selection or not.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getModified(self, **kwargs):
        """
        Sets or returns whether the field has been modified.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getNumberOfLines(self, **kwargs):
        """
        Returns the total number of lines in the document.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getObjectPathCompletion(self, **kwargs):
        """
        Enable/disable path completion                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSearchAndSelect(self, **kwargs):
        """
        Searches for (and selects) the specified search string using the specified search options.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSearchDown(self, **kwargs):
        """
        Specifies whether to search from the cursor down, or up.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSearchMatchCase(self, **kwargs):
        """
        Specifies whether the search is to be case sensitive or not.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSearchString(self, **kwargs):
        """
        Specifies the string to search for.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSearchWraps(self, **kwargs):
        """
        Specifies whether the search should wrap around.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSelectedText(self, **kwargs):
        """
        The text in the current selection range.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getShowLineNumbers(self, **kwargs):
        """
        Shows/hides the line numbes column.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getShowTooltipHelp(self, **kwargs):
        """
        Enable/disable tooltips in the command execution window                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSourceType(self, **kwargs):
        """
        Sets the source type for this command executer field. Valid values are mel(enabled by default) and python.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getSpacesPerTab(self, **kwargs):
        """
        Specifies the number of spaces equivalent to one tab stop. (default 4)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getTabsForIndent(self, **kwargs):
        """
        Specifies whether tab characters should be inserted when indenting. (default on)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getText(self, **kwargs):
        """
        Replaces the field text with the given string.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getTextLength(self, **kwargs):
        """
        The number of characters in this text field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def insertText(self, val='True', **kwargs):
        """
        Inserts the specified text into the position under the cursor, replacing any currently selected text. The selection and cursor position can be set using the selectflag. Appends text to the end of this field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def load(self, val='True', **kwargs):
        """
        Prompts the user for a script to load into this field.  The loaded filename becomes associated with this executer field and saving will save directly to the file.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def loadContents(self, val='True', **kwargs):
        """
        Loads the contents of the specified filename into this field.  The path and extension for this filename is provided internally.  This command is only intended for loading the contents of this executer field from a previous instance of this executer field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def loadFile(self, val='True', **kwargs):
        """
        If the provided string is a fully specified file path, then attempts to load the file contents into this field.  If the string is empty or not valid then prompts the user for a script to load into this field.  In both cases the filename becomes associated with this executer field and saving will save directly to the file.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def modificationChangedCommand(self, val='True', **kwargs):
        """
        Sets a script which will be called whenever the content of this field changes in a way that affects the modification state. In MEL, the function should have the following signature: proc modificationChanged(int $m)If $m is true, the field has been modified; otherwise it is false.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def pasteSelection(self, val='True', **kwargs):
        """
        Pastes text into this field at the current caret position.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def redo(self, val='True', **kwargs):
        """
        Redo the last operation.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def removeStoredContents(self, val='True', **kwargs):
        """
        Removes the stored contents of this field with the specified filename.  The path and extension for the file is provided internally.  This command is only intended for removing previously stored contents of this executer field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def replaceAll(self, val='True', **kwargs):
        """
        Replaces all instances of the first string in the field text with the second string.  The case sensitivity of this operation is set with the -searchMatchCaseflag.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def saveFile(self, val='True', **kwargs):
        """
        Saves the entire script contents of this field directly to the specified file path.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def saveSelection(self, val='True', **kwargs):
        """
        Prompts to save the current selection to a file.  The default filename prompt will be prepended with the given string.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def saveSelectionToShelf(self, val='True', **kwargs):
        """
        Prompts to save the current selection to an item in the shelf.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def select(self, val='True', **kwargs):
        """
        Selects text within a specified range.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def selectAll(self, val='True', **kwargs):
        """
        Selects all text.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setAutoCloseBraces(self, val='True', **kwargs):
        """
        Specifies whether a closing brace should automatically be added when hitting enter after an opening brace. (default on)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setCommandCompletion(self, val='True', **kwargs):
        """
        Enable/disable command completion                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setCurrentLine(self, val='True', **kwargs):
        """
        Sets/returns the current line which the cursor is on.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setFilterKeyPress(self, val='True', **kwargs):
        """
        Sets a script which will be called to handle key-press events. The function should have the following signature: proc int filterKeyPress(int $modifiers, string $key)modifiers: a bit mask where Shift is bit 1, Ctrl is bit 3, Alt is bit 4, and bit 5 is the 'Windows' key on Windows keyboards and the Command key on Mac keyboards. key: Specifies what key was pressed. The key is either a single ascii character or one of the keyword strings for the special keyboard characters. For example: Up, Down, Right, Left, Home, End, Page_Up, Page_Down, Insert Return, Space F1 to F12 The function should return 1 to indicate that they key event has been handled, and 0 to indicate that it has not been handled.                   
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setModified(self, val='True', **kwargs):
        """
        Sets or returns whether the field has been modified.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setObjectPathCompletion(self, val='True', **kwargs):
        """
        Enable/disable path completion                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setSearchDown(self, val='True', **kwargs):
        """
        Specifies whether to search from the cursor down, or up.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setSearchMatchCase(self, val='True', **kwargs):
        """
        Specifies whether the search is to be case sensitive or not.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setSearchString(self, val='True', **kwargs):
        """
        Specifies the string to search for.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setSearchWraps(self, val='True', **kwargs):
        """
        Specifies whether the search should wrap around.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setShowLineNumbers(self, val='True', **kwargs):
        """
        Shows/hides the line numbes column.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setShowTooltipHelp(self, val='True', **kwargs):
        """
        Enable/disable tooltips in the command execution window                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setSpacesPerTab(self, val='True', **kwargs):
        """
        Specifies the number of spaces equivalent to one tab stop. (default 4)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setTabsForIndent(self, val='True', **kwargs):
        """
        Specifies whether tab characters should be inserted when indenting. (default on)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        Replaces the field text with the given string.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def source(self, val='True', **kwargs):
        """
        Prompts the user for a script to source (execute without loading).                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def storeContents(self, val='True', **kwargs):
        """
        If the provided string is a fully specified file path, then attempts to store the contents of this field to that path. Otherwise, uses the provided string as a filename only and uses an internally generated path and extension for the file, as used by the -loadContents and -removeStoredContents flags. In both cases, a new unique filename will be generated if the specified name exists. Returns the filename of the file saved upon completion, and an empty string otherwise.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    def undo(self, val='True', **kwargs):
        """
        Undo the last operation.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        A script editor executer control used to issue script commands to Maya.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - appendText : at                (unicode)       [create,edit]
            Appends text to the end of this field.
        
        - autoCloseBraces : acb          (bool)          [create,query,edit]
            Specifies whether a closing brace should automatically be added when hitting
            enter after an opening brace. (default on)
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - clear : clr                    (bool)          [create,edit]
            Clears the field.
        
        - commandCompletion : cco        (bool)          [create,query,edit]
            Enable/disable command completion
        
        - copySelection : cp             (bool)          [create,edit]
            Copies the current selection from this field.
        
        - currentLine : cl               (int)           [create,query,edit]
            Sets/returns the current line which the cursor is on.
        
        - cutSelection : ct              (bool)          [create,edit]
            Cuts the current selection from this field.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - execute : exc                  (bool)          [create,edit]
            Executes the current selection.  If there is no selection, all text is executed.
        
        - executeAll : exa               (bool)          [create,edit]
            Executes all text.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fileChangedCommand : fcc       (script)        [create,edit]
            Only valid when this field contains a file. Sets a script which will be called
            whenever the file is externally modified, renamed or removed from disk. In MEL,
            the function should have the following signature: proc fileChanged(string $file)
        
        - filename : fn                  (bool)          [query]
            Returns the full path + filename of the script which was either loaded or saved.
            If there isn't one returns an empty string.
        
        - filterKeyPress : fkp           (script)        [create,query,edit]
            Sets a script which will be called to handle key-press events. The function
            should have the following signature: proc int filterKeyPress(int $modifiers,
            string $key)modifiers: a bit mask where Shift is bit 1, Ctrl is bit 3, Alt is
            bit 4, and bit 5 is the 'Windows' key on Windows keyboards and the Command key
            on Mac keyboards. key: Specifies what key was pressed. The key is either a
            single ascii character or one of the keyword strings for the special keyboard
            characters. For example: Up, Down, Right, Left, Home, End, Page_Up, Page_Down,
            Insert Return, Space F1 to F12 The function should return 1 to indicate that
            they key event has been handled, and 0 to indicate that it has not been handled.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - hasFocus : hf                  (bool)          [query]
            Whether this control is currently in focus.
        
        - hasSelection : hsl             (bool)          [query]
            Whether this control currently has a selection or not.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - indentSelection : isl          (bool)          []
        
        - insertText : it                (unicode)       [create,edit]
            Inserts the specified text into the position under the cursor, replacing any
            currently selected text. The selection and cursor position can be set using the
            selectflag. Appends text to the end of this field.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - load : ld                      (bool)          [create,edit]
            Prompts the user for a script to load into this field.  The loaded filename
            becomes associated with this executer field and saving will save directly to the
            file.
        
        - loadContents : ldc             (unicode)       [create,edit]
            Loads the contents of the specified filename into this field.  The path and
            extension for this filename is provided internally.  This command is only
            intended for loading the contents of this executer field from a previous
            instance of this executer field.
        
        - loadFile : ldf                 (unicode)       [create,edit]
            If the provided string is a fully specified file path, then attempts to load the
            file contents into this field.  If the string is empty or not valid then prompts
            the user for a script to load into this field.  In both cases the filename
            becomes associated with this executer field and saving will save directly to the
            file.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - modificationChangedCommand : mcc (script)        [create,edit]
            Sets a script which will be called whenever the content of this field changes in
            a way that affects the modification state. In MEL, the function should have the
            following signature: proc modificationChanged(int $m)If $m is true, the field
            has been modified; otherwise it is false.
        
        - modified : mod                 (bool)          [query,edit]
            Sets or returns whether the field has been modified.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfLines : nl             (int)           [query]
            Returns the total number of lines in the document.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - objectPathCompletion : opc     (bool)          [create,query,edit]
            Enable/disable path completion
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - pasteSelection : pst           (bool)          [create,edit]
            Pastes text into this field at the current caret position.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - receiveFocusCommand : rfc      (callable)      []
        
        - redo : rd                      (bool)          [create,edit]
            Redo the last operation.
        
        - removeStoredContents : rsc     (unicode)       [create,edit]
            Removes the stored contents of this field with the specified filename.  The path
            and extension for the file is provided internally.  This command is only
            intended for removing previously stored contents of this executer field.
        
        - replaceAll : rpa               (unicode, unicode) [create,edit]
            Replaces all instances of the first string in the field text with the second
            string.  The case sensitivity of this operation is set with the
            -searchMatchCaseflag.
        
        - saveFile : svf                 (unicode)       [create,edit]
            Saves the entire script contents of this field directly to the specified file
            path.
        
        - saveSelection : sv             (unicode)       [create,edit]
            Prompts to save the current selection to a file.  The default filename prompt
            will be prepended with the given string.
        
        - saveSelectionToShelf : svs     (bool)          [create,edit]
            Prompts to save the current selection to an item in the shelf.
        
        - searchAndSelect : sas          (bool)          [query]
            Searches for (and selects) the specified search string using the specified
            search options.
        
        - searchDown : sd                (bool)          [create,query,edit]
            Specifies whether to search from the cursor down, or up.
        
        - searchMatchCase : smc          (bool)          [create,query,edit]
            Specifies whether the search is to be case sensitive or not.
        
        - searchString : ss              (unicode)       [create,query,edit]
            Specifies the string to search for.
        
        - searchWraps : sw               (bool)          [create,query,edit]
            Specifies whether the search should wrap around.
        
        - select : sl                    (int, int)      [create,edit]
            Selects text within a specified range.
        
        - selectAll : sla                (bool)          [create,edit]
            Selects all text.
        
        - selectedText : slt             (bool)          [query]
            The text in the current selection range.
        
        - showLineNumbers : sln          (bool)          [create,query,edit]
            Shows/hides the line numbes column.
        
        - showTooltipHelp : sth          (bool)          [create,query,edit]
            Enable/disable tooltips in the command execution window
        
        - source : src                   (bool)          [create,edit]
            Prompts the user for a script to source (execute without loading).
        
        - sourceType : st                (unicode)       [create,query]
            Sets the source type for this command executer field. Valid values are
            mel(enabled by default) and python.
        
        - spacesPerTab : spt             (int)           [create,query,edit]
            Specifies the number of spaces equivalent to one tab stop. (default 4)
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - storeContents : stc            (unicode)       [create,edit]
            If the provided string is a fully specified file path, then attempts to store
            the contents of this field to that path. Otherwise, uses the provided string as
            a filename only and uses an internally generated path and extension for the
            file, as used by the -loadContents and -removeStoredContents flags. In both
            cases, a new unique filename will be generated if the specified name exists.
            Returns the filename of the file saved upon completion, and an empty string
            otherwise.
        
        - tabsForIndent : tfi            (bool)          [create,query,edit]
            Specifies whether tab characters should be inserted when indenting. (default on)
        
        - text : t                       (unicode)       [create,query,edit]
            Replaces the field text with the given string.
        
        - textLength : tl                (bool)          [query]
            The number of characters in this text field.
        
        - undo : ud                      (bool)          [create,edit]
            Undo the last operation.
        
        - unindentSelection : usl        (bool)          []
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldExecuter`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'cmdScrollFieldExecuter'
    
    
    __melui__ = 'cmdScrollFieldExecuter'


class Menu(PyUI):
    def __enter__(self): pass
    def __exit__(self, type, value, traceback): pass
    def deleteAllItems(self, val='True', **kwargs):
        """
        Delete all the items in this menu.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getAllowOptionBoxes(self, **kwargs):
        """
        Deprecated. All menus now always allow option boxes. Indicate whether the menu will be able to support option box menu items.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the menu.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getEnable(self, **kwargs):
        """
        Enables/disables the menu.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getFamilyImage(self, **kwargs):
        """
        The filename of the icon associated with the menu. This icon will be used if a menu item does not have an icon image defined.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getHelpMenu(self, **kwargs):
        """
        Indicates that this menu is the help menu and will be the right most menu in the menu bar. On Unix systems the help menu is also right justified in the menu bar.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getItemArray(self):
        """
        Modified to return pymel instances
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that is displayed for the menu.  If no label is supplied then the menuName will be used.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getMnemonic(self, **kwargs):
        """
        Set the Alt key to post that menu.  The character specified must match the case of its corresponding character in the menu item text, but selection from the keyboard is case insensitive.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getNumberOfItems(self, **kwargs):
        """
        Return number of items in the menu.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getPostMenuCommandOnce(self, **kwargs):
        """
        Indicate the -pmc/postMenuCommandshould only be invoked once.  Default value is false, ie. the -pmc/postMenuCommandis invoked every time the menu is shown.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getScrollable(self, **kwargs):
        """
        Make the popup menus support scrolling. Default value is false.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this menu feature was introduced. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def getVisible(self, **kwargs):
        """
        Shows/hides the menu.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def makeDefault(self):
        """
        set this layout as the default parent
        """
        pass
    def postMenuCommand(self, val='True', **kwargs):
        """
        Specify a script to be executed when the menu is about to be shown.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the menu.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        Enables/disables the menu.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setFamilyImage(self, val='True', **kwargs):
        """
        The filename of the icon associated with the menu. This icon will be used if a menu item does not have an icon image defined.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setHelpMenu(self, val='True', **kwargs):
        """
        Indicates that this menu is the help menu and will be the right most menu in the menu bar. On Unix systems the help menu is also right justified in the menu bar.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that is displayed for the menu.  If no label is supplied then the menuName will be used.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setMnemonic(self, val='True', **kwargs):
        """
        Set the Alt key to post that menu.  The character specified must match the case of its corresponding character in the menu item text, but selection from the keyboard is case insensitive.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setPostMenuCommandOnce(self, val='True', **kwargs):
        """
        Indicate the -pmc/postMenuCommandshould only be invoked once.  Default value is false, ie. the -pmc/postMenuCommandis invoked every time the menu is shown.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setScrollable(self, val='True', **kwargs):
        """
        Make the popup menus support scrolling. Default value is false.                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this menu feature was introduced. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        Shows/hides the menu.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a new menu and adds it to the default window's menubar if
        no parent is specified.  The menu can be enabled/disabled. Note that this
        command may also be used on menu objects created using the command menuItem
        -sm/subMenu true.
        
        Flags:
        - allowOptionBoxes : aob         (bool)          [create,query]
            Deprecated. All menus now always allow option boxes. Indicate whether the menu
            will be able to support option box menu items.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteAllItems : dai           (bool)          [create,edit]
            Delete all the items in this menu.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the menu.
        
        - enable : en                    (bool)          [create,query,edit]
            Enables/disables the menu.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - familyImage : fi               (unicode)       [create,query,edit]
            The filename of the icon associated with the menu. This icon will be used if a
            menu item does not have an icon image defined.
        
        - helpMenu : hm                  (bool)          [create,query,edit]
            Indicates that this menu is the help menu and will be the right most menu in the
            menu bar. On Unix systems the help menu is also right justified in the menu bar.
        
        - itemArray : ia                 (bool)          [query]
            Return string array of the menu item names.
        
        - label : l                      (unicode)       [create,query,edit]
            The text that is displayed for the menu.  If no label is supplied then the
            menuName will be used.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g.
            2014.5 should be given as 2014).
        
        - mnemonic : mn                  (unicode)       [create,query,edit]
            Set the Alt key to post that menu.  The character specified must match the case
            of its corresponding character in the menu item text, but selection from the
            keyboard is case insensitive.
        
        - numberOfItems : ni             (bool)          [query]
            Return number of items in the menu.
        
        - parent : p                     (unicode)       [create]
            Specify the window that the menu will appear in.
        
        - postMenuCommand : pmc          (script)        [create,edit]
            Specify a script to be executed when the menu is about to be shown.
        
        - postMenuCommandOnce : pmo      (bool)          [create,query,edit]
            Indicate the -pmc/postMenuCommandshould only be invoked once.  Default value is
            false, ie. the -pmc/postMenuCommandis invoked every time the menu is shown.
        
        - scrollable : srb               (bool)          [create,query,edit]
            Make the popup menus support scrolling. Default value is false.
        
        - tearOff : to                   (bool)          [create]
            Makes the menu tear-off-able.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this menu feature was introduced. The argument should
            be given as a string of the version number (e.g. 2014, 2015). Currently only
            accepts major version numbers (e.g. 2014.5 should be given as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            Shows/hides the menu.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.menu`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'menu'
    
    
    __melui__ = 'menu'


class TextCurves(PyUI):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The textCurves command creates NURBS curves from a text string using the
        specified font. A single letter can be made up of more than one NURBS curve. The
        number of curves per letter varies with the font.
        
        Flags:
        - caching : cch                  (bool)          []
        
        - constructionHistory : ch       (bool)          []
        
        - deprecatedFontName : dfn       (bool)          []
        
        - font : f                       (unicode)       [create]
            The font to use.
        
        - frozen : fzn                   (bool)          []
        
        - name : n                       (unicode)       [create]
            Sets the name of the newly-created node. If it contains namespace path, the new
            node will be created under the specified namespace; if the namespace does not
            exist, it will be created.
        
        - nodeState : nds                (int)           []
        
        - object : o                     (bool)          [create]
            Create the result, or just the dependency node.
        
        - text : t                       (unicode)       [create]
            The string to create the curves for.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.textCurves`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'textCurves'
    
    
    __melui__ = 'textCurves'


class ExclusiveLightCheckBox(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def label(self, val='True', **kwargs):
        """
        Value of the checkbox label                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a checkBox that controls a light's exclusive non-exclusive
        status.  An exclusive light is one that is not hooked up to the default-light-
        list, thus it does not illuminate all objects be default.  However an exclusive
        light can be linked to an object.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,edit]
            Value of the checkbox label
        
        - light : lt                     (PyNode)        [create]
            The light that is to be made exclusive/non-exclusive.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.exclusiveLightCheckBox`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'exclusiveLightCheckBox'
    
    
    __melui__ = 'exclusiveLightCheckBox'


class DefaultLightListCheckBox(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def label(self, val='True', **kwargs):
        """
        Value of the checkbox label                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def shadingGroup(self, val='True', **kwargs):
        """
        The shading group that is to be connected/disconnected from the defaultLightList.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a checkBox that controls whether a shadingGroup is
        connected/disconnected from the defaultLightList.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,edit]
            Value of the checkbox label
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - shadingGroup : sg              (PyNode)        [create,edit]
            The shading group that is to be connected/disconnected from the
            defaultLightList.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.defaultLightListCheckBox`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'defaultLightListCheckBox'
    
    
    __melui__ = 'defaultLightListCheckBox'


class IconTextRadioButton(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getAlign(self, **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getChangeCommand(self, **kwargs):
        """
        Command executed when the control's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the control from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getDisabledImage(self, **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getFlat(self, **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getFlipX(self, **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getFlipY(self, **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getHighlightImage(self, **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getImage(self, **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getImage1(self, **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getImage2(self, **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getImage3(self, **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getLabelOffset(self, **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getMarginHeight(self, **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getMarginWidth(self, **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getOffCommand(self, **kwargs):
        """
        Command executed when the control is turned off.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getOnCommand(self, **kwargs):
        """
        Command executed when the control is turned on.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getOverlayLabelBackColor(self, **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getOverlayLabelColor(self, **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getRotation(self, **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Will set this button as the selected one.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getSelectionHighlightImage(self, **kwargs):
        """
        Image displayed while the control is selected and the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getSelectionImage(self, **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getStyle(self, **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getUseAlpha(self, **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setChangeCommand(self, val='True', **kwargs):
        """
        Command executed when the control's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the control from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setDisabledImage(self, val='True', **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setFlat(self, val='True', **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setFlipX(self, val='True', **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setFlipY(self, val='True', **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setHighlightImage(self, val='True', **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setImage1(self, val='True', **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setImage2(self, val='True', **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setImage3(self, val='True', **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setLabelOffset(self, val='True', **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setMarginHeight(self, val='True', **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setMarginWidth(self, val='True', **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setOffCommand(self, val='True', **kwargs):
        """
        Command executed when the control is turned off.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setOnCommand(self, val='True', **kwargs):
        """
        Command executed when the control is turned on.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setOverlayLabelBackColor(self, val='True', **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setOverlayLabelColor(self, val='True', **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setRotation(self, val='True', **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Will set this button as the selected one.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setSelectionHighlightImage(self, val='True', **kwargs):
        """
        Image displayed while the control is selected and the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setSelectionImage(self, val='True', **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setUseAlpha(self, val='True', **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This control supports up to 3 icon images and 4 different display styles.  The
        icon image displayed is the one that best fits the current size of the control
        given its current style. This command creates a iconTextRadioButton that is
        added to the most recently created iconTextRadioCollection unless the
        -cl/cluster flag is used.
        
        Flags:
        - align : al                     (unicode)       [create,query,edit]
            The label alignment.  Alignment values are left, right, and center. By default,
            the label is aligned center. Currently only available when -st/style is set to
            iconAndTextCentered.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,query,edit]
            Command executed when the control's state is changed. Note that this flag should
            not be used in conjunction with onCommand and offCommand. That is, one should
            either use changeCommand and test the state of the control from inside the
            callback, or use onCommand and offCommand as separate callbacks.
        
        - collection : cl                (unicode)       [create]
            To explicitly add the control to the specified collection.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disabledImage : di             (unicode)       [create,query,edit]
            Image used when the button is disabled. Image size must be the same as the image
            specified with the i/imageflag. This is a Windows only flag.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - flat : fla                     (bool)          [create,query,edit]
            Sets whether the control will be a flat button (0 false, 1 true).
        
        - flipX : fx                     (bool)          [create,query,edit]
            Is the image flipped horizontally?
        
        - flipY : fy                     (bool)          [create,query,edit]
            Is the image flipped vertically?
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - highlightImage : hi            (unicode)       [create,query,edit]
            Highlight image displayed while the cursor is over the control. Image size must
            be the same as the image specified with the -i/imageflag. This is a Windows only
            flag.
        
        - image : i                      (unicode)       [create,query,edit]
            If you are not providing images with different sizes then you may use this flag
            for the control's image. If the iconOnlystyle is set, the icon will be scaled to
            the size of the control.
        
        - image1 : i1                    (unicode)       [create,query,edit]
            First of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image2 : i2                    (unicode)       [create,query,edit]
            Second of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image3 : i3                    (unicode)       [create,query,edit]
            Third of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            A short string, up to 6 characters, representing a label that will be displayed
            on top of the image.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The text that appears in the control.
        
        - labelOffset : lo               (int)           [create,query,edit]
            The label offset. Default is 0. Currently only available when -st/style is set
            to iconAndTextCentered.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - marginHeight : mh              (int)           [create,query,edit]
            The number of pixels above and below the control content. The default value is 1
            pixel.
        
        - marginWidth : mw               (int)           [create,query,edit]
            The number of pixels on either side of the control content. The default value is
            1 pixel.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - offCommand : ofc               (script)        [create,query,edit]
            Command executed when the control is turned off.
        
        - onCommand : onc                (script)        [create,query,edit]
            Command executed when the control is turned on.
        
        - overlayLabelBackColor : olb    (float, float, float, float) [create,query,edit]
            The RGBA color of the shadow behind the label defined by imageOverlayLabel.
            Default is 50% transparent black: 0 0 0 .5
        
        - overlayLabelColor : olc        (float, float, float) [create,query,edit]
            The RGB color of the label defined by imageOverlayLabel. Default is a light
            grey: .8 .8 .8
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rotation : rot                 (float)         [create,query,edit]
            The rotation value of the image in radians.
        
        - select : sl                    (bool)          [create,query,edit]
            Will set this button as the selected one.
        
        - selectionHighlightImage : shi  (unicode)       [create,query,edit]
            Image displayed while the control is selected and the cursor is over the
            control. Image size must be the same as the image specified with the
            -i/imageflag. This is a Windows only flag.
        
        - selectionImage : si            (unicode)       [create,query,edit]
            Image displayed while the control is selected. Image size must be the same as
            the image specified with the -i/imageflag. This is a Windows only flag.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            The draw style of the control.  Valid styles are iconOnly, textOnly,
            iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note:
            iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set,
            the icon will be scaled to the size of the control.
        
        - useAlpha : ua                  (bool)          [create,query,edit]
            Is the image using alpha channel?
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this control feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.iconTextRadioButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'iconTextRadioButton'
    
    
    __melui__ = 'iconTextRadioButton'


class AnimCurveEditor(PyUI):
    """
    # ------ Do not edit below this line --------
    """
    
    
    
    def denormalizeCurvesCommand(self, val='True', **kwargs):
        """
        Sets the script that is run to denormalize curves in the graph editor. This is intended for internal use only.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def displayActiveKeyTangents(self, val='True', **kwargs):
        """
        on | off | tgl Display active key tangents in the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def displayActiveKeys(self, val='True', **kwargs):
        """
        on | off | tgl Display active keys in the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def displayInfinities(self, val='True', **kwargs):
        """
        on | off | tgl Display infinities in the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def displayKeys(self, val='True', **kwargs):
        """
        on | off | tgl Display keyframes in the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def displayTangents(self, val='True', **kwargs):
        """
        on | off | tgl Display tangents in the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def displayValues(self, val='True', **kwargs):
        """
        on | off | tgl Display active keys and tangents values in the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getAreCurvesSelected(self, **kwargs):
        """
        Returns a boolean to know if at least one curve is selected in the graph editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getAutoFit(self, **kwargs):
        """
        on | off | tgl Auto fit-to-view.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getAutoFitTime(self, **kwargs):
        """
        on | off | tgl Auto fit-to-view along the time axis, as well.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getClassicMode(self, **kwargs):
        """
        When on, the graph editor is displayed in Classic Mode, otherwise Suites Modeis used.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getClipTime(self, **kwargs):
        """
        Valid values: onoffDisplay the clips with their offset and scale applied to the anim curves in the clip.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getConstrainDrag(self, **kwargs):
        """
        Constrains all Graph Editor animation curve drag operations to either the X-axis, the Y-axis, or to neither of those axes. Values to supply are: 0 for not constraining any axis, 1 for constraing the X-axis, or 2 for constraining the Y-axis. When used in queries, this flag returns the latter values and these values have the same interpretation as above. Note: when the shift key is pressed before dragging the animation curve, the first mouse movement will instead determine (and override) any prior set constrained axis.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getCurvesShown(self, **kwargs):
        """
        Returns a string array containing the names of the animCurve nodes currently displayed in the graph editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getCurvesShownForceUpdate(self, **kwargs):
        """
        Returns a string array containing the names of the animCurve nodes currently displayed in the graph editor. Unlike the curvesShown flag, this will force an update of the graph editor for the case where the mainListConnection has been modified since the last refresh.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getDisplayNormalized(self, **kwargs):
        """
        When on, display all curves normalized to the range -1 to +1.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getKeyingTime(self, **kwargs):
        """
        The current time in the given curve to be keyed in the graph editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getOutliner(self, **kwargs):
        """
        The name of the outliner that is associated with the graph editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getPreSelectionHighlight(self, **kwargs):
        """
        When on, the curve/key/tangent under the mouse pointer is highlighted to ease selection.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getResultSamples(self, **kwargs):
        """
        Specify the sampling for result curves Note: the smaller this number is, the longer it will take to update the display.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getResultScreenSamples(self, **kwargs):
        """
        Specify the screen base result sampling for result curves. If 0, then results are sampled in time.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getResultUpdate(self, **kwargs):
        """
        Valid values: interactivedelayedControls how changes to animCurves are reflected in the result curves (if results are being shown).  If resultUpdate is interactive, then as interactive changes are being made to the animCurve, the result curves will be updated.  If modelUpdate is delayed (which is the default setting), then result curves are updated once the final change to an animCurve has been made.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getShowActiveCurveNames(self, **kwargs):
        """
        Display the active curve(s)'s name.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getShowBufferCurves(self, **kwargs):
        """
        Valid values: onofftglDisplay buffer curves.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getShowCurveNames(self, **kwargs):
        """
        Display the curves's name.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getShowResults(self, **kwargs):
        """
        Valid values: onofftglDisplay result curves from expression or other non-keyed action.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getShowUpstreamCurves(self, **kwargs):
        """
        If true, the dependency graph is searched upstream for all curves that drive the selected plugs (showing multiple curves for example in a typical driven key setup, where first the driven key curve is encountered, followed by the actual animation curve that drives the source object). If false, only the first curves encountered will be shown. Note that, even if false, multiple curves can be shown if e.g. a blendWeighted node is being used to combine multiple curves.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getSmoothness(self, **kwargs):
        """
        Valid values: coarseroughmediumfineSpecify the display smoothness of animation curves.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getSnapTime(self, **kwargs):
        """
        none | integer | keyframe Keyframe move snap in time.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getSnapValue(self, **kwargs):
        """
        none | integer | keyframe Keyframe move snap in values.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getStackedCurves(self, **kwargs):
        """
        Switches the display mode between normal (all curves sharing one set of axes) to stacked (each curve on its own value axis, stacked vertically).                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getStackedCurvesMax(self, **kwargs):
        """
        Sets the maximum value on the per-curve value axis when in stacked mode.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getStackedCurvesMin(self, **kwargs):
        """
        Sets the minimum value on the per-curve value axis when in stacked mode.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getStackedCurvesSpace(self, **kwargs):
        """
        Sets the spacing between curves when in stacked mode.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def lookAt(self, val='True', **kwargs):
        """
        all | selected | currentTime FitView helpers.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def normalizeCurvesCommand(self, val='True', **kwargs):
        """
        Sets the script that is run to normalize curves in the graph editor. This is intended for internal use only.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def renormalizeCurves(self, val='True', **kwargs):
        """
        This flag causes the curve normalization factors to be recalculated.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setAutoFit(self, val='True', **kwargs):
        """
        on | off | tgl Auto fit-to-view.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setAutoFitTime(self, val='True', **kwargs):
        """
        on | off | tgl Auto fit-to-view along the time axis, as well.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setClassicMode(self, val='True', **kwargs):
        """
        When on, the graph editor is displayed in Classic Mode, otherwise Suites Modeis used.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setClipTime(self, val='True', **kwargs):
        """
        Valid values: onoffDisplay the clips with their offset and scale applied to the anim curves in the clip.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setConstrainDrag(self, val='True', **kwargs):
        """
        Constrains all Graph Editor animation curve drag operations to either the X-axis, the Y-axis, or to neither of those axes. Values to supply are: 0 for not constraining any axis, 1 for constraing the X-axis, or 2 for constraining the Y-axis. When used in queries, this flag returns the latter values and these values have the same interpretation as above. Note: when the shift key is pressed before dragging the animation curve, the first mouse movement will instead determine (and override) any prior set constrained axis.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setDisplayNormalized(self, val='True', **kwargs):
        """
        When on, display all curves normalized to the range -1 to +1.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setOutliner(self, val='True', **kwargs):
        """
        The name of the outliner that is associated with the graph editor.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setPreSelectionHighlight(self, val='True', **kwargs):
        """
        When on, the curve/key/tangent under the mouse pointer is highlighted to ease selection.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setResultSamples(self, val='True', **kwargs):
        """
        Specify the sampling for result curves Note: the smaller this number is, the longer it will take to update the display.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setResultScreenSamples(self, val='True', **kwargs):
        """
        Specify the screen base result sampling for result curves. If 0, then results are sampled in time.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setResultUpdate(self, val='True', **kwargs):
        """
        Valid values: interactivedelayedControls how changes to animCurves are reflected in the result curves (if results are being shown).  If resultUpdate is interactive, then as interactive changes are being made to the animCurve, the result curves will be updated.  If modelUpdate is delayed (which is the default setting), then result curves are updated once the final change to an animCurve has been made.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setShowActiveCurveNames(self, val='True', **kwargs):
        """
        Display the active curve(s)'s name.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setShowBufferCurves(self, val='True', **kwargs):
        """
        Valid values: onofftglDisplay buffer curves.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setShowCurveNames(self, val='True', **kwargs):
        """
        Display the curves's name.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setShowResults(self, val='True', **kwargs):
        """
        Valid values: onofftglDisplay result curves from expression or other non-keyed action.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setShowUpstreamCurves(self, val='True', **kwargs):
        """
        If true, the dependency graph is searched upstream for all curves that drive the selected plugs (showing multiple curves for example in a typical driven key setup, where first the driven key curve is encountered, followed by the actual animation curve that drives the source object). If false, only the first curves encountered will be shown. Note that, even if false, multiple curves can be shown if e.g. a blendWeighted node is being used to combine multiple curves.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setSmoothness(self, val='True', **kwargs):
        """
        Valid values: coarseroughmediumfineSpecify the display smoothness of animation curves.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setSnapTime(self, val='True', **kwargs):
        """
        none | integer | keyframe Keyframe move snap in time.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setSnapValue(self, val='True', **kwargs):
        """
        none | integer | keyframe Keyframe move snap in values.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setStackedCurves(self, val='True', **kwargs):
        """
        Switches the display mode between normal (all curves sharing one set of axes) to stacked (each curve on its own value axis, stacked vertically).                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setStackedCurvesMax(self, val='True', **kwargs):
        """
        Sets the maximum value on the per-curve value axis when in stacked mode.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setStackedCurvesMin(self, val='True', **kwargs):
        """
        Sets the minimum value on the per-curve value axis when in stacked mode.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def setStackedCurvesSpace(self, val='True', **kwargs):
        """
        Sets the spacing between curves when in stacked mode.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    def valueLinesToggle(self, val='True', **kwargs):
        """
        on | off | tgl Display the value lines for high/low/zero of selected curves in the editor                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Edit a characteristic of a graph editor
        
        Flags:
        - areCurvesSelected : acs        (bool)          [query]
            Returns a boolean to know if at least one curve is selected in the graph editor.
        
        - autoFit : af                   (unicode)       [query,edit]
            on | off | tgl Auto fit-to-view.
        
        - autoFitTime : aft              (unicode)       [query,edit]
            on | off | tgl Auto fit-to-view along the time axis, as well.
        
        - classicMode : cm               (bool)          [query,edit]
            When on, the graph editor is displayed in Classic Mode, otherwise Suites Modeis
            used.
        
        - clipTime : ct                  (unicode)       [query,edit]
            Valid values: onoffDisplay the clips with their offset and scale applied to the
            anim curves in the clip.
        
        - constrainDrag : cd             (int)           [create,query,edit]
            Constrains all Graph Editor animation curve drag operations to either the
            X-axis, the Y-axis, or to neither of those axes. Values to supply are: 0 for not
            constraining any axis, 1 for constraing the X-axis, or 2 for constraining the
            Y-axis. When used in queries, this flag returns the latter values and these
            values have the same interpretation as above. Note: when the shift key is
            pressed before dragging the animation curve, the first mouse movement will
            instead determine (and override) any prior set constrained axis.
        
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - curvesShown : cs               (bool)          [query]
            Returns a string array containing the names of the animCurve nodes currently
            displayed in the graph editor.
        
        - curvesShownForceUpdate : csf   (bool)          [query]
            Returns a string array containing the names of the animCurve nodes currently
            displayed in the graph editor. Unlike the curvesShown flag, this will force an
            update of the graph editor for the case where the mainListConnection has been
            modified since the last refresh.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - denormalizeCurvesCommand : dcc (unicode)       [create,edit]
            Sets the script that is run to denormalize curves in the graph editor. This is
            intended for internal use only.
        
        - displayActiveKeyTangents : dat (unicode)       [edit]
            on | off | tgl Display active key tangents in the editor.
        
        - displayActiveKeys : dak        (unicode)       [edit]
            on | off | tgl Display active keys in the editor.
        
        - displayInfinities : di         (unicode)       [edit]
            on | off | tgl Display infinities in the editor.
        
        - displayKeys : dk               (unicode)       [edit]
            on | off | tgl Display keyframes in the editor.
        
        - displayNormalized : dn         (bool)          [query,edit]
            When on, display all curves normalized to the range -1 to +1.
        
        - displayTangents : dtn          (unicode)       [edit]
            on | off | tgl Display tangents in the editor.
        
        - displayValues : dv             (unicode)       [edit]
            on | off | tgl Display active keys and tangents values in the editor.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - keyingTime : kt                (unicode)       [query]
            The current time in the given curve to be keyed in the graph editor.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - lookAt : la                    (unicode)       [edit]
            all | selected | currentTime FitView helpers.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - menu : m                       (script)        [create]
            Specify a script to be run when the editor is created.  The function will be
            passed one string argument which is the new editor's name.
        
        - normalizeCurvesCommand : ncc   (unicode)       [create,edit]
            Sets the script that is run to normalize curves in the graph editor. This is
            intended for internal use only.
        
        - outliner : o                   (unicode)       [query,edit]
            The name of the outliner that is associated with the graph editor.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - preSelectionHighlight : psh    (bool)          [query,edit]
            When on, the curve/key/tangent under the mouse pointer is highlighted to ease
            selection.
        
        - renormalizeCurves : rnc        (bool)          [edit]
            This flag causes the curve normalization factors to be recalculated.
        
        - resultSamples : rs             (time)          [query,edit]
            Specify the sampling for result curves Note: the smaller this number is, the
            longer it will take to update the display.
        
        - resultScreenSamples : rss      (int)           [query,edit]
            Specify the screen base result sampling for result curves. If 0, then results
            are sampled in time.
        
        - resultUpdate : ru              (unicode)       [query,edit]
            Valid values: interactivedelayedControls how changes to animCurves are reflected
            in the result curves (if results are being shown).  If resultUpdate is
            interactive, then as interactive changes are being made to the animCurve, the
            result curves will be updated.  If modelUpdate is delayed (which is the default
            setting), then result curves are updated once the final change to an animCurve
            has been made.
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - showActiveCurveNames : acn     (bool)          [query,edit]
            Display the active curve(s)'s name.
        
        - showBufferCurves : sb          (unicode)       [query,edit]
            Valid values: onofftglDisplay buffer curves.
        
        - showCurveNames : scn           (bool)          [query,edit]
            Display the curves's name.
        
        - showResults : sr               (unicode)       [query,edit]
            Valid values: onofftglDisplay result curves from expression or other non-keyed
            action.
        
        - showUpstreamCurves : suc       (bool)          [query,edit]
            If true, the dependency graph is searched upstream for all curves that drive the
            selected plugs (showing multiple curves for example in a typical driven key
            setup, where first the driven key curve is encountered, followed by the actual
            animation curve that drives the source object). If false, only the first curves
            encountered will be shown. Note that, even if false, multiple curves can be
            shown if e.g. a blendWeighted node is being used to combine multiple curves.
        
        - smoothness : s                 (unicode)       [query,edit]
            Valid values: coarseroughmediumfineSpecify the display smoothness of animation
            curves.
        
        - snapTime : st                  (unicode)       [query,edit]
            none | integer | keyframe Keyframe move snap in time.
        
        - snapValue : sv                 (unicode)       [query,edit]
            none | integer | keyframe Keyframe move snap in values.
        
        - stackedCurves : sc             (bool)          [query,edit]
            Switches the display mode between normal (all curves sharing one set of axes) to
            stacked (each curve on its own value axis, stacked vertically).
        
        - stackedCurvesMax : scx         (float)         [query,edit]
            Sets the maximum value on the per-curve value axis when in stacked mode.
        
        - stackedCurvesMin : scm         (float)         [query,edit]
            Sets the minimum value on the per-curve value axis when in stacked mode.
        
        - stackedCurvesSpace : scs       (float)         [query,edit]
            Sets the spacing between curves when in stacked mode.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - valueLinesToggle : vlt         (unicode)       [edit]
            on | off | tgl Display the value lines for high/low/zero of selected curves in
            the editor                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        - viewLeft : vl                  (float)         []
        
        - viewRight : vr                 (float)         []
        
        
        Derived from mel command `maya.cmds.animCurveEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'animCurveEditor'
    
    
    __melui__ = 'animCurveEditor'


class RenderLayerButton(PyUI):
    __melui__ = 'renderLayerButton'


class IconTextScrollList(PyUI):
    def append(self, val='True', **kwargs):
        """
        Add an item to the end of the list.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Script to run when the list changes                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def deselectAll(self, val='True', **kwargs):
        """
        Deselect all items.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def doubleClickCommand(self, val='True', **kwargs):
        """
        Specify the command to be executed when an item is double clicked.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def dragFeedbackVisible(self, val='True', **kwargs):
        """
        Should the drag feedback be shown in the scrollbar?                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def dropRectCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is hovering above the drop site.  It returns the shape of the rectangle to be drawn to highlight the entry, if the control can receive the dropped data. The MEL version of the callback is of the form: global proc int[] callbackName(string $dropControl, int $x, int $y) The return value is an array of size 4, with the parameters, in order, being the left and top coordinates of the rectangle to be drawn, followed by the width and height. This functionality is currently only implemented in MEL.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def editIndexed(self, val='True', **kwargs):
        """
        Index of the edited field                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def editable(self, val='True', **kwargs):
        """
        Set the field to be editable or not                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getAllowMultiSelection(self, **kwargs):
        """
        Specify multi or single selection mode.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getItemAt(self, **kwargs):
        """
        Return the name of the item, if any, located at given point       
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getNumberOfIcons(self, **kwargs):
        """
        Number of icons.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getNumberOfRows(self, **kwargs):
        """
        Number of visible rows.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getSelectIndexedItem(self, **kwargs):
        """
        Select the indexed item. Indices are 1-based.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getSelectItem(self, **kwargs):
        """
        Select the item that contains the specified text.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getVisualRectAt(self, **kwargs):
        """
        Return the visual rectangle of the item, if any, located at given point. The result is a an array of 4 integers, in local coordinates, describing the rectangle, in the following order: left, top, width, height.       
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def itemTextColor(self, val='True', **kwargs):
        """
        Set the text color of the item at the given index. Arguments are: index, red, green, and blue. Indices are 1-based. Each color component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def removeAll(self, val='True', **kwargs):
        """
        Remove all items.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def selectCommand(self, val='True', **kwargs):
        """
        Specify the command to be executed when an item is selected.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setAllowMultiSelection(self, val='True', **kwargs):
        """
        Specify multi or single selection mode.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setSelectIndexedItem(self, val='True', **kwargs):
        """
        Select the indexed item. Indices are 1-based.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setSelectItem(self, val='True', **kwargs):
        """
        Select the item that contains the specified text.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a text scrolling list. The list can be in
        single select mode where only one item at at time is selected, or in multi-
        select mode where many items may be selected.
        
        Flags:
        - allowMultiSelection : ams      (bool)          [create,query,edit]
            Specify multi or single selection mode.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - append : a                     (unicode)       [create,edit]
            Add an item to the end of the list.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Script to run when the list changes
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deselectAll : da               (bool)          [create,edit]
            Deselect all items.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,edit]
            Specify the command to be executed when an item is double clicked.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragFeedbackVisible : dfv      (bool)          [create,edit]
            Should the drag feedback be shown in the scrollbar?
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - dropRectCallback : drc         (script)        [edit]
            Adds a callback that is called when a drag and drop operation is hovering above
            the drop site.  It returns the shape of the rectangle to be drawn to highlight
            the entry, if the control can receive the dropped data. The MEL version of the
            callback is of the form: global proc int[] callbackName(string $dropControl, int
            $x, int $y) The return value is an array of size 4, with the parameters, in
            order, being the left and top coordinates of the rectangle to be drawn, followed
            by the width and height. This functionality is currently only implemented in
            MEL.
        
        - editIndexed : ei               (int)           [create,edit]
            Index of the edited field
        
        - editable : ed                  (bool)          [create,edit]
            Set the field to be editable or not
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - itemAt : ia                    (int, int)      [query]
            Return the name of the item, if any, located at given point
        
        - itemTextColor : itc            (int, float, float, float) [create,edit]
            Set the text color of the item at the given index. Arguments are: index, red,
            green, and blue. Indices are 1-based. Each color component ranges in value from
            0.0 to 1.0.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfIcons : nic            (int)           [query]
            Number of icons.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - numberOfRows : nr              (bool)          [query]
            Number of visible rows.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - removeAll : ra                 (bool)          [create,edit]
            Remove all items.
        
        - selectCommand : sc             (script)        [create,edit]
            Specify the command to be executed when an item is selected.
        
        - selectIndexedItem : sii        (int)           [create,query,edit]
            Select the indexed item. Indices are 1-based.
        
        - selectItem : si                (unicode)       [create,query,edit]
            Select the item that contains the specified text.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - visualRectAt : vra             (int, int)      [query]
            Return the visual rectangle of the item, if any, located at given point. The
            result is a an array of 4 integers, in local coordinates, describing the
            rectangle, in the following order: left, top, width, height.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.iconTextScrollList`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'iconTextScrollList'
    
    
    __melui__ = 'iconTextScrollList'


class CmdShell(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Command executed when the contents change.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getNumberOfHistoryLines(self, **kwargs):
        """
        The number of input lines to be saved in the command history buffer.  You can cycle through this buffer by pressing the up and down arrow keys.  Valid values are 0 through 32767.  Any value less than 0 will be handled as if 0 was specified.  Similarly, any value greater than 32767 will be handled as if 32767 was specified.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getNumberOfSavedLines(self, **kwargs):
        """
        The total number of lines (the scrolled lines and currently visible lines) that will be remembered by the field. Any lines beyond this number will be lost, and the user will not be able to review them by scrolling.  Valid values are 1 through 32767.  Any value less than 1 will be handled as if 1 was specified.  Similarly, any value greater than 32767 will be handled as if 32767 was specified.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getPrompt(self, **kwargs):
        """
        The text that is used as a prompt.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        Command executed when the contents change.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setNumberOfHistoryLines(self, val='True', **kwargs):
        """
        The number of input lines to be saved in the command history buffer.  You can cycle through this buffer by pressing the up and down arrow keys.  Valid values are 0 through 32767.  Any value less than 0 will be handled as if 0 was specified.  Similarly, any value greater than 32767 will be handled as if 32767 was specified.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setNumberOfSavedLines(self, val='True', **kwargs):
        """
        The total number of lines (the scrolled lines and currently visible lines) that will be remembered by the field. Any lines beyond this number will be lost, and the user will not be able to review them by scrolling.  Valid values are 1 through 32767.  Any value less than 1 will be handled as if 1 was specified.  Similarly, any value greater than 32767 will be handled as if 32767 was specified.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setPrompt(self, val='True', **kwargs):
        """
        The text that is used as a prompt.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a scrolling field that behaves similar to a unix shell for
        entering user input.  You may specify the number of lines that will be
        remembered by the field with the -nsl/numberOfSavedLines flag.  The default
        number of lines saved is 100.  The shellField also maintains a command history
        buffer. You can specify the number of input lines that will be saved with the
        -hlc/historyLineCount flag.  The default size of this buffer is 10.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - clear : cl                     (bool)          [create]
            Erases all visible text, and also deletes any text that had scrolled of the top
            of the field.  After clearing the field it will be blank, and you will not be
            able to scroll up to see previous lines.  This flag does not affect the command
            history buffer, however.
        
        - command : c                    (unicode)       [create,query,edit]
            Command executed when the contents change.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfHistoryLines : nhl     (int)           [create,query,edit]
            The number of input lines to be saved in the command history buffer.  You can
            cycle through this buffer by pressing the up and down arrow keys.  Valid values
            are 0 through 32767.  Any value less than 0 will be handled as if 0 was
            specified.  Similarly, any value greater than 32767 will be handled as if 32767
            was specified.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - numberOfSavedLines : nsl       (int)           [create,query,edit]
            The total number of lines (the scrolled lines and currently visible lines) that
            will be remembered by the field. Any lines beyond this number will be lost, and
            the user will not be able to review them by scrolling.  Valid values are 1
            through 32767.  Any value less than 1 will be handled as if 1 was specified.
            Similarly, any value greater than 32767 will be handled as if 32767 was
            specified.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - prompt : pr                    (unicode)       [create,query,edit]
            The text that is used as a prompt.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.cmdShell`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'cmdShell'
    
    
    __melui__ = 'cmdShell'


class PyUIContainer(PyUI):
    def __enter__(self): pass
    def __exit__(self, type, value, traceback): pass
    def addChild(self, uiType, name='None', **kwargs): pass
    def findChild(self, shortName, recurse='False'):
        """
        Parameters
        ----------
        shortName : str
        recurse : bool
        
        Returns
        -------
        Optional[PyUI]
        """
        pass
    def makeDefault(self):
        """
        set this layout as the default parent
        """
        pass
    def pop(self):
        """
        set the default parent to the parent of this layout
        """
        pass
    def walkChildren(self):
        """
        recursively yield all children of this layout
        
        Returns
        -------
        Iterator[PyUI]
        """
        pass


class TextField(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the text changes.  This command is not invoked when the value changes via the -tx/text flag.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def enterCommand(self, val='True', **kwargs):
        """
        Command executed when the keypad 'Enter' key is pressed.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getAlwaysInvokeEnterCommandOnReturn(self, **kwargs):
        """
        Sets whether to always invoke the enter command when the return key is pressed by the user. By default, this option is false.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getDisableButtons(self, **kwargs):
        """
        Sets the visibility state of search field buttons to true/false depending on the passed value. In Query mode returns whether both buttons are visible or not.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getDisableClearButton(self, **kwargs):
        """
        Sets the visibility state of search field clear button to true/false depending on the passed value. In Query mode returns whether clear button of search field is visible or not.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getDisableHistoryButton(self, **kwargs):
        """
        Sets the visibility state of search field history button to true/false depending on the passed value. In Query mode returns whether history button of search field is visible or not.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getDrawInactiveFrame(self, **kwargs):
        """
        Sets whether the text field draws itself with a frame when it's inactive. By default, this option is false.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/text flag regardless of the state of the -ed/editable flag.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getFileName(self, **kwargs):
        """
        Text in the field as a filename. This does conversions between internal and external (UI) file representation.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getInsertionPosition(self, **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getPlaceholderText(self, **kwargs):
        """
        Setting this property makes the line edit display a grayed-out placeholder text as long as the text field is empty and the widget doesn't have focus. By default, this property contains an empty string.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getText(self, **kwargs):
        """
        The field text.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def insertText(self, val='True', **kwargs):
        """
        Insert text into the field at the current insertion position (specified by the -ip/insertionPosition flag).                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def receiveFocusCommand(self, val='True', **kwargs):
        """
        Command executed when the field receives focus.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setAlwaysInvokeEnterCommandOnReturn(self, val='True', **kwargs):
        """
        Sets whether to always invoke the enter command when the return key is pressed by the user. By default, this option is false.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setDisableButtons(self, val='True', **kwargs):
        """
        Sets the visibility state of search field buttons to true/false depending on the passed value. In Query mode returns whether both buttons are visible or not.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setDisableClearButton(self, val='True', **kwargs):
        """
        Sets the visibility state of search field clear button to true/false depending on the passed value. In Query mode returns whether clear button of search field is visible or not.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setDisableHistoryButton(self, val='True', **kwargs):
        """
        Sets the visibility state of search field history button to true/false depending on the passed value. In Query mode returns whether history button of search field is visible or not.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setDrawInactiveFrame(self, val='True', **kwargs):
        """
        Sets whether the text field draws itself with a frame when it's inactive. By default, this option is false.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/text flag regardless of the state of the -ed/editable flag.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setFileName(self, val='True', **kwargs):
        """
        Text in the field as a filename. This does conversions between internal and external (UI) file representation.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setInsertionPosition(self, val='True', **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setPlaceholderText(self, val='True', **kwargs):
        """
        Setting this property makes the line edit display a grayed-out placeholder text as long as the text field is empty and the widget doesn't have focus. By default, this property contains an empty string.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        The field text.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    def textChangedCommand(self, val='True', **kwargs):
        """
        Command executed immediately when the field text changes.                  
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a text field control.
        
        Flags:
        - alwaysInvokeEnterCommandOnReturn : aie (bool)          [create,query,edit]
            Sets whether to always invoke the enter command when the return key is pressed
            by the user. By default, this option is false.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the text changes.  This command is not invoked when the
            value changes via the -tx/text flag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disableButtons : db            (bool)          [create,query,edit]
            Sets the visibility state of search field buttons to true/false depending on the
            passed value. In Query mode returns whether both buttons are visible or not.
        
        - disableClearButton : dcb       (bool)          [create,query,edit]
            Sets the visibility state of search field clear button to true/false depending
            on the passed value. In Query mode returns whether clear button of search field
            is visible or not.
        
        - disableHistoryButton : dhb     (bool)          [create,query,edit]
            Sets the visibility state of search field history button to true/false depending
            on the passed value. In Query mode returns whether history button of search
            field is visible or not.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - drawInactiveFrame : dif        (bool)          [create,query,edit]
            Sets whether the text field draws itself with a frame when it's inactive. By
            default, this option is false.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the field.  By default, this flag is set to true and the field
            value may be changed by typing into it. If false then the field is 'read only'
            and can not be typed into. The text in the field can always be changed with the
            -tx/text flag regardless of the state of the -ed/editable flag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enterCommand : ec              (script)        [create,edit]
            Command executed when the keypad 'Enter' key is pressed.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fileName : fi                  (unicode)       [create,query,edit]
            Text in the field as a filename. This does conversions between internal and
            external (UI) file representation.
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - insertText : it                (unicode)       [create,edit]
            Insert text into the field at the current insertion position (specified by the
            -ip/insertionPosition flag).
        
        - insertionPosition : ip         (int)           [create,query,edit]
            The insertion position for inserted text.  This is a 1 based value where
            position 1 specifies the beginning of the field.  Position 0 may be used to
            specify the end of the field.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - placeholderText : pht          (unicode)       [create,query,edit]
            Setting this property makes the line edit display a grayed-out placeholder text
            as long as the text field is empty and the widget doesn't have focus. By
            default, this property contains an empty string.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - receiveFocusCommand : rfc      (script)        [create,edit]
            Command executed when the field receives focus.
        
        - searchField : sf               (bool)          [create]
            Creates a search field instead of a text field.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - text : tx                      (unicode)       [create,query,edit]
            The field text.
        
        - textChangedCommand : tcc       (script)        [create,edit]
            Command executed immediately when the field text changes.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.textField`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'textField'
    
    
    __melui__ = 'textField'


class GradientControlNoAttr(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Specifies a command to be executed whenever the value of this ramp is modified. This option should not be used when specifying an optionVar.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def currentKeyChanged(self, val='True', **kwargs):
        """
        Specifies a command to be executed whenever the selected key changes.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Specifies a command to be executed while the ramp is being modified.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getAsString(self, **kwargs):
        """
        Used to query and set the value of the ramp as a string of comma separated values                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getCurrentKey(self, **kwargs):
        """
        Returns the index of the currently selected key.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getCurrentKeyColorValue(self, **kwargs):
        """
        Get or set the color of the currently selected key. Only useful if the ramp is set to be a color ramp.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getCurrentKeyCurveValue(self, **kwargs):
        """
        Get or set the value of the currently selected key. Only useful if the ramp is set to be a curve ramp.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getCurrentKeyInterpValue(self, **kwargs):
        """
        Get or set the interpolation value for the current key.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getOptionVar(self, **kwargs):
        """
        Specifies the name of the option var used to store and retrieve the string value capturing the curve.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getRampAsColor(self, **kwargs):
        """
        Sets whether the ramp should be viewed as a colour ramp or as a curve.  Default is as a curve.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getValueAtPoint(self, **kwargs):
        """
        Used during query to specify the point at which to query the curve.       
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setAsString(self, val='True', **kwargs):
        """
        Used to query and set the value of the ramp as a string of comma separated values                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setCurrentKey(self, val='True', **kwargs):
        """
        Returns the index of the currently selected key.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setCurrentKeyColorValue(self, val='True', **kwargs):
        """
        Get or set the color of the currently selected key. Only useful if the ramp is set to be a color ramp.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setCurrentKeyCurveValue(self, val='True', **kwargs):
        """
        Get or set the value of the currently selected key. Only useful if the ramp is set to be a curve ramp.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setCurrentKeyInterpValue(self, val='True', **kwargs):
        """
        Get or set the interpolation value for the current key.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setOptionVar(self, val='True', **kwargs):
        """
        Specifies the name of the option var used to store and retrieve the string value capturing the curve.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setRampAsColor(self, val='True', **kwargs):
        """
        Sets whether the ramp should be viewed as a colour ramp or as a curve.  Default is as a curve.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a control for editing a ramp (2D control curve). The
        control attaches to an optionVar used to store and retrieve the encoded gradient
        control points stored in a string.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - asString : asString            (unicode)       [query,edit]
            Used to query and set the value of the ramp as a string of comma separated
            values
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [edit]
            Specifies a command to be executed whenever the value of this ramp is modified.
            This option should not be used when specifying an optionVar.
        
        - currentKey : ck                (int)           [create,query,edit]
            Returns the index of the currently selected key.
        
        - currentKeyChanged : ckc        (script)        [edit]
            Specifies a command to be executed whenever the selected key changes.
        
        - currentKeyColorValue : clv     (float, float, float) [query,edit]
            Get or set the color of the currently selected key. Only useful if the ramp is
            set to be a color ramp.
        
        - currentKeyCurveValue : cvv     (bool)          [query,edit]
            Get or set the value of the currently selected key. Only useful if the ramp is
            set to be a curve ramp.
        
        - currentKeyInterpValue : civ    (int)           [query,edit]
            Get or set the interpolation value for the current key.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [edit]
            Specifies a command to be executed while the ramp is being modified.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - optionVar : ov                 (unicode)       [create,query,edit]
            Specifies the name of the option var used to store and retrieve the string value
            capturing the curve.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rampAsColor : rac              (bool)          [create,query,edit]
            Sets whether the ramp should be viewed as a colour ramp or as a curve.  Default
            is as a curve.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - valueAtPoint : vap             (float)         [query]
            Used during query to specify the point at which to query the curve.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.gradientControlNoAttr`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'gradientControlNoAttr'
    
    
    __melui__ = 'gradientControlNoAttr'


class ClipSchedulerOutliner(PyUI):
    def clipScheduler(self, val='True', **kwargs):
        """
        Name of the clip scheduler for which to display information.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a clip scheduler outliner control.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - clipScheduler : cs             (unicode)       [edit]
            Name of the clip scheduler for which to display information.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.clipSchedulerOutliner`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'clipSchedulerOutliner'
    
    
    __melui__ = 'clipSchedulerOutliner'


class KeyframeStats(PyUI):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getAnimEditor(self, **kwargs):
        """
        The name of the animation editor which is associated with the control                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getClassicMode(self, **kwargs):
        """
        Edit display mode. True means stats only, otherwise show time value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getPrecision(self, **kwargs):
        """
        Controls the number of digits to the right of the decimal point that will be displayed for float-valued channels. Default is 3.  Queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getTimeAnnotation(self, **kwargs):
        """
        Annotate the time field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getValueAnnotation(self, **kwargs):
        """
        Annotate the value field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setAnimEditor(self, val='True', **kwargs):
        """
        The name of the animation editor which is associated with the control                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setClassicMode(self, val='True', **kwargs):
        """
        Edit display mode. True means stats only, otherwise show time value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setPrecision(self, val='True', **kwargs):
        """
        Controls the number of digits to the right of the decimal point that will be displayed for float-valued channels. Default is 3.  Queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setTimeAnnotation(self, val='True', **kwargs):
        """
        Annotate the time field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setValueAnnotation(self, val='True', **kwargs):
        """
        Annotate the value field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates, edits, queries a keyframe stats control.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - animEditor : ae                (unicode)       [query,edit]
            The name of the animation editor which is associated with the control
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - classicMode : cm               (bool)          [query,edit]
            Edit display mode. True means stats only, otherwise show time value.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [query,edit]
            Controls the number of digits to the right of the decimal point that will be
            displayed for float-valued channels. Default is 3.  Queried, returns an int.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - timeAnnotation : tan           (unicode)       [create,query,edit]
            Annotate the time field with an extra string value.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - valueAnnotation : van          (unicode)       [create,query,edit]
            Annotate the value field with an extra string value.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.keyframeStats`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'keyframeStats'
    
    
    __melui__ = 'keyframeStats'


class GlRenderEditor(PyUI):
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getLookThru(self, **kwargs):
        """
        Specify which camera the glRender view should be using.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def getViewCameraName(self, **kwargs):
        """
        Returns the name of the current camera used by the glRenderPanel. This is a query only flag.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setLookThru(self, val='True', **kwargs):
        """
        Specify which camera the glRender view should be using.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a glRender view. This is a special view used for hardware rendering. This
        command is used to create and reparent the view as needed to support panels. See
        the glRender command for controlling the specific behavior of the hardware
        rendering. In query mode, return type is based on queried flag.
        
        Flags:
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - lookThru : lt                  (unicode)       [create,query,edit]
            Specify which camera the glRender view should be using.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - viewCameraName : vcn           (bool)          [query]
            Returns the name of the current camera used by the glRenderPanel. This is a
            query only flag.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.glRenderEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'glRenderEditor'
    
    
    __melui__ = 'glRenderEditor'


class Button(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getActOnPress(self, **kwargs):
        """
        If true then the command specified by the command flag will be executed when a mouse button is pressed.  If false then that command will be executed after the mouse button is released. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getActionIsSubstitute(self, **kwargs):
        """
        This flag is obsolete and should no longer be used.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getAlign(self, **kwargs):
        """
        This flag is obsolete and should no longer be used. The button label will always be center-aligned.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Command executed when the control is pressed.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The label text.  The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getRecomputeSize(self, **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setActOnPress(self, val='True', **kwargs):
        """
        If true then the command specified by the command flag will be executed when a mouse button is pressed.  If false then that command will be executed after the mouse button is released. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setActionIsSubstitute(self, val='True', **kwargs):
        """
        This flag is obsolete and should no longer be used.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        This flag is obsolete and should no longer be used. The button label will always be center-aligned.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        Command executed when the control is pressed.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The label text.  The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setRecomputeSize(self, val='True', **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a button control capable of displaying a textual label and executing a
        command when selected by the user.
        
        Flags:
        - actOnPress : aop               (bool)          [create,query,edit]
            If true then the command specified by the command flag will be executed when a
            mouse button is pressed.  If false then that command will be executed after the
            mouse button is released. The default value is false.
        
        - actionIsSubstitute : ais       (bool)          [create,query,edit]
            This flag is obsolete and should no longer be used.
        
        - align : al                     (unicode)       [create,query,edit]
            This flag is obsolete and should no longer be used. The button label will always
            be center-aligned.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - command : c                    (script)        [create,query,edit]
            Command executed when the control is pressed.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The label text.  The default label is the name of the control.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - recomputeSize : rs             (bool)          [create,query,edit]
            If true then the control will recompute it's size to just fit the size of the
            label.  If false then the control size will remain fixed as you change the size
            of the label.  The default value of this flag is true.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.button`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'button'
    
    
    __melui__ = 'button'


class ScrollField(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes. This command is executed whenever the field loses focus.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def clear(self, val='True', **kwargs):
        """
        Removes all text in the field.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def command(self, val='True', **kwargs):
        """
        Obsolete - use enterCommandinstead                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def enterCommand(self, val='True', **kwargs):
        """
        Command executed when the enter key is pressed. This applies to the enter key on the numeric keypad only.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/text flag regardless of the state of the -ed/editable flag.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getFontPointSize(self, **kwargs):
        """
        The font point size for the text.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getInsertionPosition(self, **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getNumberOfLines(self, **kwargs):
        """
        Number of lines in the scroll field.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getQtFont(self, **kwargs):
        """
        The Qt font family for the text.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getSelection(self, **kwargs):
        """
        The selected text in the field.  An empty string is returned if there is no selected text.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getText(self, **kwargs):
        """
        The field text.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def insertText(self, val='True', **kwargs):
        """
        Insert text into the field at the current insertion position (specified by the -ip/insertionPosition flag).                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def keyPressCommand(self, val='True', **kwargs):
        """
        Command executed when any key is pressed.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/text flag regardless of the state of the -ed/editable flag.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setFontPointSize(self, val='True', **kwargs):
        """
        The font point size for the text.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setInsertionPosition(self, val='True', **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setQtFont(self, val='True', **kwargs):
        """
        The Qt font family for the text.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        The field text.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a scrolling field that handles multiple lines of text.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the value changes. This command is executed whenever the
            field loses focus.
        
        - clear : cl                     (bool)          [create,edit]
            Removes all text in the field.
        
        - command : c                    (unicode)       [create,edit]
            Obsolete - use enterCommandinstead
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the field.  By default, this flag is set to true and the field
            value may be changed by typing into it. If false then the field is 'read only'
            and can not be typed into. The text in the field can always be changed with the
            -tx/text flag regardless of the state of the -ed/editable flag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enterCommand : ec              (script)        [create,edit]
            Command executed when the enter key is pressed. This applies to the enter key on
            the numeric keypad only.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fontPointSize : fns            (int)           [create,query,edit]
            The font point size for the text.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - insertText : it                (unicode)       [create,edit]
            Insert text into the field at the current insertion position (specified by the
            -ip/insertionPosition flag).
        
        - insertionPosition : ip         (int)           [create,query,edit]
            The insertion position for inserted text.  This is a 1 based value where
            position 1 specifies the beginning of the field.  Position 0 may be used to
            specify the end of the field.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - keyPressCommand : kpc          (script)        [create,edit]
            Command executed when any key is pressed.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfLines : nl             (int)           [query]
            Number of lines in the scroll field.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - qtFont : qfn                   (unicode)       [create,query,edit]
            The Qt font family for the text.
        
        - selection : sl                 (bool)          [query]
            The selected text in the field.  An empty string is returned if there is no
            selected text.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - text : tx                      (unicode)       [create,query,edit]
            The field text.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.
        
        - wordWrap : ww                  (bool)          [create]
            Specify true to break lines at spaces, tabs, or newlines.  Text will continue on
            the following line.  A value of false will not break text between words, in
            which case text may disappear beyond the edge of the field.  This flag must be
            set at create time. Lines do not word wrap by default.                  Flag can
            have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.scrollField`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'scrollField'
    
    
    __melui__ = 'scrollField'


class IntSlider(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes.  This command is not invoked when the value changes via the -v/value flag.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes by dragging the slider's value marker.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getHorizontal(self, **kwargs):
        """
        Orientation of the slider.  This flag is true by default, which corresponds to a horizontally oriented slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Upper limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Lower limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getStep(self, **kwargs):
        """
        The step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Upper limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Lower limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        The step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a slider control that accepts only integer values and is bound by a
        minimum and maximum value.  The slider displays a marker indicating the current
        value of the slider relative to its minimum and maximum values.  Click and drag
        the marker or on the slider itself to change the current value.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the value changes.  This command is not invoked when the
            value changes via the -v/value flag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command executed when the value changes by dragging the slider's value marker.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontal : hr                (bool)          [create,query]
            Orientation of the slider.  This flag is true by default, which corresponds to a
            horizontally oriented slider.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (int)           [create,query,edit]
            Upper limit of the slider.
        
        - minValue : min                 (int)           [create,query,edit]
            Lower limit of the slider.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (int)           [create,query,edit]
            The step value represents the amount the value will increase or decrease when
            you click either side of the slider.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (int)           [create,query,edit]
            Value of the slider.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.intSlider`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'intSlider'
    
    
    __melui__ = 'intSlider'


class ColorEditor(PyUI):
    def getAlpha(self, **kwargs):
        """
        Float values corresponding to the alpha transparency component, , which ranges from 0.0 to 1.0.  Use this flag to specify the initial alpha value of the Color Editor, or query this flag to determine the alpha value set in the editor.                  
        
        
        Derived from mel command `maya.cmds.colorEditor`
        """
        pass
    def getHsvValue(self, **kwargs):
        """
        Three float values corresponding to the hue, saturation, and value color components, where the hue value ranges from 0.0 to 360.0 and the saturation and value components range from 0.0 to 1.0.  Use this flag to specify the initial color of the Color Editor, or query this flag to determine the color set in the editor.                  
        
        
        Derived from mel command `maya.cmds.colorEditor`
        """
        pass
    def getResult(self, **kwargs):
        """
        This query only flag returns true if the dialog's OKbutton was pressed, false otherwise.  If you query this flag immediately after showing the Color Editor then it will return the same value as the boolean value returned in the colorEditorcommand's return string.                  
        
        
        Derived from mel command `maya.cmds.colorEditor`
        """
        pass
    def getRgbValue(self, **kwargs):
        """
        Three float values corresponding to the red, green, and blue color components, all of which range from 0.0 to 1.0.  Use this flag to specify the initial color of the Color Editor, or query this flag to determine the color set in the editor.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.colorEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The colorEditorcommand displays a modal dialog that may be used to specify
        colors in RGB or HSV. The default behaviour when no arguments are specified is
        to provide an initial color of black (rgb 0.0 0.0 0.0). The command will return
        the user's color component values along with a boolean to indicate whether the
        dialog was dismissed by pressing the OKbutton.  As an alternative to responding
        to the colorEditorcommand's return string you can now query the -rgb/rgbValue,
        -hsv/hsvValue, and -r/resultflags to get the same information. The final
        argument is 1 if the dialog's OKbutton was pressed, and 0 if the Cancelbutton
        was pressed.In query mode, return type is based on queried flag.
        
        Flags:
        - alpha : a                      (float)         [create,query]
            Float values corresponding to the alpha transparency component, , which ranges
            from 0.0 to 1.0.  Use this flag to specify the initial alpha value of the Color
            Editor, or query this flag to determine the alpha value set in the editor.
        
        - hsvValue : hsv                 (float, float, float) [create,query]
            Three float values corresponding to the hue, saturation, and value color
            components, where the hue value ranges from 0.0 to 360.0 and the saturation and
            value components range from 0.0 to 1.0.  Use this flag to specify the initial
            color of the Color Editor, or query this flag to determine the color set in the
            editor.
        
        - mini : m                       (bool)          [create]
            Enable the mini color editor mode.
        
        - parent : p                     (unicode)       [create]
            Specify the parent window for the dialog.  The dialog will be centered on this
            window and raise and lower with it's parent. By default, the dialog is not
            parented to a particular window and is simply centered on the screen.
        
        - position : pos                 (int, int)      [create]
            Specify the window position for the dialog.
        
        - result : r                     (bool)          [query]
            This query only flag returns true if the dialog's OKbutton was pressed, false
            otherwise.  If you query this flag immediately after showing the Color Editor
            then it will return the same value as the boolean value returned in the
            colorEditorcommand's return string.
        
        - rgbValue : rgb                 (float, float, float) [create,query]
            Three float values corresponding to the red, green, and blue color components,
            all of which range from 0.0 to 1.0.  Use this flag to specify the initial color
            of the Color Editor, or query this flag to determine the color set in the
            editor.                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.colorEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'colorEditor'
    
    
    __melui__ = 'colorEditor'


class ToolButton(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the control's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the control from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def collection(self, val='True', **kwargs):
        """
        To explicitly add a tool button to a tool collection.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def doubleClickCommand(self, val='True', **kwargs):
        """
        Command executed when the control is double clicked.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getAllowMultipleTools(self, **kwargs):
        """
        Indicates whether this control will allow you to attach more than one tool.  By default, this control accepts only one tool. You can add multiple tools by setting this flag to true. Only one tool will be current and displayed at any one time. Use the pop up menu attached to the right mouse button to view all the tools.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getImage1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getImage2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getImage3(self, **kwargs):
        """
        This control supports three images.  The image that best fits the current size of the control will be displayed.  This flag applies the image to the current tool.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        A short string (5 characters) label that will be displayed on top of the icon.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getPopupIndicatorVisible(self, **kwargs):
        """
        Edit this flag to set the visibility of the popup tool indicator. The indicator is a simple image that appears in the top right corner of the button when more that one tool is associated with this control. This flag is queryable and true by default.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getTool(self, **kwargs):
        """
        The name of the tool to be attached to the button.  If the tool specified is already attached to this button then it will be selected.  Query this flag to return the current tool.  This flag may be specified more than once to attach more than one tool.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getToolArray(self, **kwargs):
        """
        This query only flag returns the names of all the tools attached to the toolButton control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getToolCount(self, **kwargs):
        """
        This query only flag return the number of tools attached to the toolButton control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getToolImage1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getToolImage2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getToolImage3(self, **kwargs):
        """
        This control supports three images.  The image that best fits the current size of the control will be displayed.  This flag applies the image to the specified tool.  The first argument is the name of the tool and the second is the name of the image.  When queried an array of tool icon pairs is returned.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this tool button feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def offCommand(self, val='True', **kwargs):
        """
        Command executed when the control is turned off.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def onCommand(self, val='True', **kwargs):
        """
        Command executed when the control is turned on.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def select(self, val='True', **kwargs):
        """
        Will set this button as the selected one.  This flag also queries the select state of the control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setImage1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setImage2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setImage3(self, val='True', **kwargs):
        """
        This control supports three images.  The image that best fits the current size of the control will be displayed.  This flag applies the image to the current tool.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        A short string (5 characters) label that will be displayed on top of the icon.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setPopupIndicatorVisible(self, val='True', **kwargs):
        """
        Edit this flag to set the visibility of the popup tool indicator. The indicator is a simple image that appears in the top right corner of the button when more that one tool is associated with this control. This flag is queryable and true by default.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setTool(self, val='True', **kwargs):
        """
        The name of the tool to be attached to the button.  If the tool specified is already attached to this button then it will be selected.  Query this flag to return the current tool.  This flag may be specified more than once to attach more than one tool.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setToolImage1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setToolImage2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setToolImage3(self, val='True', **kwargs):
        """
        This control supports three images.  The image that best fits the current size of the control will be displayed.  This flag applies the image to the specified tool.  The first argument is the name of the tool and the second is the name of the image.  When queried an array of tool icon pairs is returned.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this tool button feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    def style(self, val='True', **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontaland iconAndTextVertical.                  
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a toolButton that is added to the most recently created
        tool button collection unless the cl/collectionflag is used. It also attaches
        the named tool, activating it when this control is selected. By default, this
        control only handles one tool at a time.  Using the t/toolflag to associate a
        new tool will simply override the previous attached tool.  If you use the
        amt/allowMultipleToolsflag then you will be able to attach more than one tool
        with this control.  Only one tool will be current within the control.  To access
        the other tools press the right mouse button to display a popup menu containing
        all the tools associated with this control.  If you set the
        piv/popupIndicatorVisibleflag then a small arrow will be drawn on the control to
        indicate that additional tools are attached to this control.
        
        Flags:
        - allowMultipleTools : amt       (bool)          [create,query]
            Indicates whether this control will allow you to attach more than one tool.  By
            default, this control accepts only one tool. You can add multiple tools by
            setting this flag to true. Only one tool will be current and displayed at any
            one time. Use the pop up menu attached to the right mouse button to view all the
            tools.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the control's state is changed. Note that this flag should
            not be used in conjunction with onCommand and offCommand. That is, one should
            either use changeCommand and test the state of the control from inside the
            callback, or use onCommand and offCommand as separate callbacks.
        
        - collection : cl                (unicode)       [create,edit]
            To explicitly add a tool button to a tool collection.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,edit]
            Command executed when the control is double clicked.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - image1 : i1                    (unicode)       [create,query,edit]
        
        - image2 : i2                    (unicode)       [create,query,edit]
        
        - image3 : i3                    (unicode)       [create,query,edit]
            This control supports three images.  The image that best fits the current size
            of the control will be displayed.  This flag applies the image to the current
            tool.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            A short string (5 characters) label that will be displayed on top of the icon.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - offCommand : ofc               (script)        [create,edit]
            Command executed when the control is turned off.
        
        - onCommand : onc                (script)        [create,edit]
            Command executed when the control is turned on.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupIndicatorVisible : piv    (bool)          [create,query,edit]
            Edit this flag to set the visibility of the popup tool indicator. The indicator
            is a simple image that appears in the top right corner of the button when more
            that one tool is associated with this control. This flag is queryable and true
            by default.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - select : sl                    (bool)          [create,edit]
            Will set this button as the selected one.  This flag also queries the select
            state of the control.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,edit]
            The draw style of the control.  Valid styles are iconOnly, textOnly,
            iconAndTextHorizontaland iconAndTextVertical.
        
        - tool : t                       (unicode)       [create,query,edit]
            The name of the tool to be attached to the button.  If the tool specified is
            already attached to this button then it will be selected.  Query this flag to
            return the current tool.  This flag may be specified more than once to attach
            more than one tool.
        
        - toolArray : ta                 (bool)          [query]
            This query only flag returns the names of all the tools attached to the
            toolButton control.
        
        - toolCount : tc                 (bool)          [query]
            This query only flag return the number of tools attached to the toolButton
            control.
        
        - toolImage1 : ti1               (unicode, unicode) [create,query,edit]
        
        - toolImage2 : ti2               (unicode, unicode) [create,query,edit]
        
        - toolImage3 : ti3               (unicode, unicode) [create,query,edit]
            This control supports three images.  The image that best fits the current size
            of the control will be displayed.  This flag applies the image to the specified
            tool.  The first argument is the name of the tool and the second is the name of
            the image.  When queried an array of tool icon pairs is returned.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this tool button feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.toolButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'toolButton'
    
    
    __melui__ = 'toolButton'


class MenuEditor(PyUI):
    def cellWidthHeight(self, val='True', **kwargs):
        """
        The width and height of the icons in the menuEditor.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getCellHeight(self, **kwargs):
        """
        The height of the icons in the menuEditor.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getCellWidth(self, **kwargs):
        """
        The width of the icons in the menuEditor.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getCheckBoxPresent(self, **kwargs):
        """
        This controls whether a menu item has a check box or not. The arguments are a flag indicating presence, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getCheckBoxState(self, **kwargs):
        """
        The state of the check box associated with a menu item. The arguments are a flag indicating state, followed by the position of the menu item. This flag is ignored if the menu item does not have a check box. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getCommand(self, **kwargs):
        """
        The command or script executed by a menu item. The arguments are the command string or script name, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item or a separator item. If queried, an array of strings is returned containing all the commands. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getImage(self, **kwargs):
        """
        The filename of the icon associated with a menu item. This icon is displayed by the menuEditor to represent the menu item. The arguments are the icon filename, followed by the position of the menu item. If queried, an array of strings is returned containing all the icon filenames. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The label of a menu item. The arguments are the label text, followed by the position of the menu item. If queried, an array of strings is returned containing all the labels. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getMenuItemTypes(self, **kwargs):
        """
        This is a query only flag.  Returns an array of strings indicating the type of contents in each cell of the menuEditor.  Cells can be vacant, or may contain a regular menu item, or a separator, or a submenuitem.  In each case, the corresponding string is returned. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getOptionBoxCommand(self, **kwargs):
        """
        The command or script executed by a menu item's associated option box item. The arguments are the command string or script name, followed by the position of the menu item. This flag is ignored if the menu item does not have an associated option box item. If queried, an array of strings is returned containing all the commands. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getOptionBoxPresent(self, **kwargs):
        """
        This controls whether a menu item has an associated option box item or not. The arguments are a flag indicating presence, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getRadioButtonPresent(self, **kwargs):
        """
        This controls whether a menu item has a radio button or not. The arguments are a flag indicating presence, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getRadioButtonState(self, **kwargs):
        """
        The state of the radio button associated with a menu item. The arguments are a flag indicating state, followed by the position of the menu item. This flag is ignored if the menu item does not have a radio button. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getSeparator(self, **kwargs):
        """
        In edit mode this adds a separator to the menuEditor at the specified position. The parameters are the radialPosition and the overflowRow. If queried, an array of booleans is returned indicating if the item is a separator item. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getStyle(self, **kwargs):
        """
        This is the style of icons within the menuEditor. Valid styles are iconOnly, textOnly, iconAndTextHorizontaland iconAndTextVertical.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getSubMenuEditorsOpen(self, **kwargs):
        """
        This is a query only flag.  Returns an array of booleans, each of which indicates if a sub-menuEditor is open and attached to the menu item in a particular cell.  One boolean is returned for each cell in the menuEditor, even if the cell is vacant or contains a non-submenu item (false will be returned in both these cases).  Only when a cell contains a submenu item can true possibily be returned. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getTopLevelMenu(self, **kwargs):
        """
        The popup menu to attach to the editor.  All editing operations performed in the editor (i.e. inserting/deleting/moving an item) will be immediately reflected in this menu. This flag is ignored if the editor is a sub-menuEditor.  The editor will update gracefully if the value of the flag is changed from its initial value.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setCellHeight(self, val='True', **kwargs):
        """
        The height of the icons in the menuEditor.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setCellWidth(self, val='True', **kwargs):
        """
        The width of the icons in the menuEditor.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setCheckBoxPresent(self, val='True', **kwargs):
        """
        This controls whether a menu item has a check box or not. The arguments are a flag indicating presence, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setCheckBoxState(self, val='True', **kwargs):
        """
        The state of the check box associated with a menu item. The arguments are a flag indicating state, followed by the position of the menu item. This flag is ignored if the menu item does not have a check box. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        The command or script executed by a menu item. The arguments are the command string or script name, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item or a separator item. If queried, an array of strings is returned containing all the commands. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        The filename of the icon associated with a menu item. This icon is displayed by the menuEditor to represent the menu item. The arguments are the icon filename, followed by the position of the menu item. If queried, an array of strings is returned containing all the icon filenames. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The label of a menu item. The arguments are the label text, followed by the position of the menu item. If queried, an array of strings is returned containing all the labels. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setOptionBoxCommand(self, val='True', **kwargs):
        """
        The command or script executed by a menu item's associated option box item. The arguments are the command string or script name, followed by the position of the menu item. This flag is ignored if the menu item does not have an associated option box item. If queried, an array of strings is returned containing all the commands. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setOptionBoxPresent(self, val='True', **kwargs):
        """
        This controls whether a menu item has an associated option box item or not. The arguments are a flag indicating presence, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setRadioButtonPresent(self, val='True', **kwargs):
        """
        This controls whether a menu item has a radio button or not. The arguments are a flag indicating presence, followed by the position of the menu item. This flag is ignored if the menu item is a submenu item. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setRadioButtonState(self, val='True', **kwargs):
        """
        The state of the radio button associated with a menu item. The arguments are a flag indicating state, followed by the position of the menu item. This flag is ignored if the menu item does not have a radio button. If queried, an array of booleans is returned containing all the flags. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setSeparator(self, val='True', **kwargs):
        """
        In edit mode this adds a separator to the menuEditor at the specified position. The parameters are the radialPosition and the overflowRow. If queried, an array of booleans is returned indicating if the item is a separator item. The first 8 entries of the array correspond to radial items (in order, N, NE, ... NW), and all later entries correspond to overflow (or linear) menu items.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        This is the style of icons within the menuEditor. Valid styles are iconOnly, textOnly, iconAndTextHorizontaland iconAndTextVertical.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setTopLevelMenu(self, val='True', **kwargs):
        """
        The popup menu to attach to the editor.  All editing operations performed in the editor (i.e. inserting/deleting/moving an item) will be immediately reflected in this menu. This flag is ignored if the editor is a sub-menuEditor.  The editor will update gracefully if the value of the flag is changed from its initial value.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    def subMenuAt(self, val='True', **kwargs):
        """
        Creates a submenu item at the given position.  A submenu item created within the radial portion of a menu will overwrite whatever item (if any) is currently at the given position. A submenu item created within the overflow (linear) portion of a menu will be inserted before the item currently at the given position.                  
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        A menuEditor displays the contents of a popup menu and allows the menu's items
        to be edited. Menu items are represented by labelled icons which can be dragged
        around within the editor to change the menu's layout.  Various objects can be
        dragged and dropped into the menuEditor to create new menu items: toolButtons
        from the shelf or toolbox, shelfButtons from the shelf, iconTextButtons with
        attached commands, and scripts from the command window. When editing a Marking
        Menu, the radial menu items correspond to 8 icons arranged in a circle within
        the menuEditor.  Overflow items in the Marking Menu (or linear items in a normal
        menu) are displayed in a column below the radial items. To edit a submenu of a
        popup menu, a new menuEditor instance must be created (typically within its own
        window) and attached to its parent menuEditor. Some flags require the position
        of a menu item to be passed in as an argument.  For these, positions are
        specified with a (string,int) pair, where the string corresponds to a radial
        position (possibily None) and the int corresponds to a linear position (possibly
        equal to 0 for none).  Radial positions are specified by one of (N,0), (NE,0),
        (E,0), (SE,0), (S,0), (SW,0), (W,0) or (NW,0).  Overflow, or linear positions,
        are specified with (None,i), where i is a 1-based index giving the position of
        the item within the overflow column.Note:This command is not meant to be called
        explicitly. It was created to support the Marking Menu editor. It is recommended
        that you use that editor to modify marking menus.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - cellHeight : ch                (int)           [query,edit]
            The height of the icons in the menuEditor.
        
        - cellWidth : cw                 (int)           [query,edit]
            The width of the icons in the menuEditor.
        
        - cellWidthHeight : cwh          (int, int)      [edit]
            The width and height of the icons in the menuEditor.
        
        - checkBoxPresent : cbp          (bool, unicode, int) [query,edit]
            This controls whether a menu item has a check box or not. The arguments are a
            flag indicating presence, followed by the position of the menu item. This flag
            is ignored if the menu item is a submenu item. If queried, an array of booleans
            is returned containing all the flags. The first 8 entries of the array
            correspond to radial items (in order, N, NE, ... NW), and all later entries
            correspond to overflow (or linear) menu items.
        
        - checkBoxState : cbs            (bool, unicode, int) [query,edit]
            The state of the check box associated with a menu item. The arguments are a flag
            indicating state, followed by the position of the menu item. This flag is
            ignored if the menu item does not have a check box. If queried, an array of
            booleans is returned containing all the flags. The first 8 entries of the array
            correspond to radial items (in order, N, NE, ... NW), and all later entries
            correspond to overflow (or linear) menu items.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - command : c                    (unicode, unicode, int) [query,edit]
            The command or script executed by a menu item. The arguments are the command
            string or script name, followed by the position of the menu item. This flag is
            ignored if the menu item is a submenu item or a separator item. If queried, an
            array of strings is returned containing all the commands. The first 8 entries of
            the array correspond to radial items (in order, N, NE, ... NW), and all later
            entries correspond to overflow (or linear) menu items.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - delete : d                     (unicode, int)  [edit]
            Deletes the menu item at the given position, removing it from the menu.  If the
            menu item has a submenu, and a sub-menuEditor is open and attached to it, then
            the sub-menuEditor's window and all its child menuEditor windows will be closed
            recursively.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - iconMenuCallback : imc         (unicode)       [create]
            This is the name of a MEL callback procedure that is called to create the popup
            menus attached to icons in the menuEditor.  The callback is called once for each
            newly created icon, and once each time an icon is moved within the menuEditor.
            Popup menus created by the callback should contain commands for editing the menu
            item associated with the icon.  Operations accessible through the menu should
            include deletion of the item, editing of the item's
            label/command/image/checkbox/optionbox, creation of a submenu, and popping up a
            sub-menuEditor. The arguments to the callback must match this form:
            callbackProc(string $menuEditorName, string $parentIconName, string $menuTitle,
            string $radialPosition, int $overflowRow); The popup menu's parent should be
            $parentIconName. Note that when a sub-menuEditor is created, this flag need not
            be re-specified as it adopts a default value equal to the value of its parent
            menuEditor's -imc/iconMenuCallback flag.
        
        - image : i                      (unicode, unicode, int) [query,edit]
            The filename of the icon associated with a menu item. This icon is displayed by
            the menuEditor to represent the menu item. The arguments are the icon filename,
            followed by the position of the menu item. If queried, an array of strings is
            returned containing all the icon filenames. The first 8 entries of the array
            correspond to radial items (in order, N, NE, ... NW), and all later entries
            correspond to overflow (or linear) menu items.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode, unicode, int) [query,edit]
            The label of a menu item. The arguments are the label text, followed by the
            position of the menu item. If queried, an array of strings is returned
            containing all the labels. The first 8 entries of the array correspond to radial
            items (in order, N, NE, ... NW), and all later entries correspond to overflow
            (or linear) menu items.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - menuItemTypes : mit            (bool)          [query]
            This is a query only flag.  Returns an array of strings indicating the type of
            contents in each cell of the menuEditor.  Cells can be vacant, or may contain a
            regular menu item, or a separator, or a submenuitem.  In each case, the
            corresponding string is returned. The first 8 entries of the array correspond to
            radial items (in order, N, NE, ... NW), and all later entries correspond to
            overflow (or linear) menu items.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - optionBoxCommand : obc         (unicode, unicode, int) [query,edit]
            The command or script executed by a menu item's associated option box item. The
            arguments are the command string or script name, followed by the position of the
            menu item. This flag is ignored if the menu item does not have an associated
            option box item. If queried, an array of strings is returned containing all the
            commands. The first 8 entries of the array correspond to radial items (in order,
            N, NE, ... NW), and all later entries correspond to overflow (or linear) menu
            items.
        
        - optionBoxPresent : obp         (bool, unicode, int) [query,edit]
            This controls whether a menu item has an associated option box item or not. The
            arguments are a flag indicating presence, followed by the position of the menu
            item. This flag is ignored if the menu item is a submenu item. If queried, an
            array of booleans is returned containing all the flags. The first 8 entries of
            the array correspond to radial items (in order, N, NE, ... NW), and all later
            entries correspond to overflow (or linear) menu items.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - radioButtonPresent : rbp       (bool, unicode, int) [query,edit]
            This controls whether a menu item has a radio button or not. The arguments are a
            flag indicating presence, followed by the position of the menu item. This flag
            is ignored if the menu item is a submenu item. If queried, an array of booleans
            is returned containing all the flags. The first 8 entries of the array
            correspond to radial items (in order, N, NE, ... NW), and all later entries
            correspond to overflow (or linear) menu items.
        
        - radioButtonState : rbs         (bool, unicode, int) [query,edit]
            The state of the radio button associated with a menu item. The arguments are a
            flag indicating state, followed by the position of the menu item. This flag is
            ignored if the menu item does not have a radio button. If queried, an array of
            booleans is returned containing all the flags. The first 8 entries of the array
            correspond to radial items (in order, N, NE, ... NW), and all later entries
            correspond to overflow (or linear) menu items.
        
        - separator : sp                 (unicode, int)  [query,edit]
            In edit mode this adds a separator to the menuEditor at the specified position.
            The parameters are the radialPosition and the overflowRow. If queried, an array
            of booleans is returned indicating if the item is a separator item. The first 8
            entries of the array correspond to radial items (in order, N, NE, ... NW), and
            all later entries correspond to overflow (or linear) menu items.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [query,edit]
            This is the style of icons within the menuEditor. Valid styles are iconOnly,
            textOnly, iconAndTextHorizontaland iconAndTextVertical.
        
        - subMenuAt : sma                (unicode, int)  [edit]
            Creates a submenu item at the given position.  A submenu item created within the
            radial portion of a menu will overwrite whatever item (if any) is currently at
            the given position. A submenu item created within the overflow (linear) portion
            of a menu will be inserted before the item currently at the given position.
        
        - subMenuEditorWindow : sew      (unicode)       [create]
            The name of the window which contains a sub-menuEditor.  Only use when creatitg
            a sub-menuEditor. This window will automatically be closed if a parent
            menuEditor is closed or if a parent menu item is deleted.
        
        - subMenuEditorsOpen : seo       (bool)          [query]
            This is a query only flag.  Returns an array of booleans, each of which
            indicates if a sub-menuEditor is open and attached to the menu item in a
            particular cell.  One boolean is returned for each cell in the menuEditor, even
            if the cell is vacant or contains a non-submenu item (false will be returned in
            both these cases).  Only when a cell contains a submenu item can true possibily
            be returned. The first 8 entries of the array correspond to radial items (in
            order, N, NE, ... NW), and all later entries correspond to overflow (or linear)
            menu items.
        
        - subMenuOf : smo                (unicode, unicode, int) [create]
            Attaches a sub-menuEditor to its parent menuEditor.  Only use when creatitg a
            sub-menuEditor. The arguments are the name of the parent menuEditor, followed by
            the position of a submenu item within the parent. A submenu item must already
            exist within the parent at the given position. A submenu item cannot have
            multiple sub-menuEditors attached to it.
        
        - topLevelMenu : tlm             (unicode)       [query,edit]
            The popup menu to attach to the editor.  All editing operations performed in the
            editor (i.e. inserting/deleting/moving an item) will be immediately reflected in
            this menu. This flag is ignored if the editor is a sub-menuEditor.  The editor
            will update gracefully if the value of the flag is changed from its initial
            value.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.menuEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'menuEditor'
    
    
    __melui__ = 'menuEditor'


class HelpLine(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a help line where tool help/hints are shown.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.helpLine`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'helpLine'
    
    
    __melui__ = 'helpLine'


class LayerButton(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Set the command to call on a change of any kind.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def color(self, val='True', **kwargs):
        """
        Layer color, specified with normalized real numbers in R, G, B space.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def command(self, val='True', **kwargs):
        """
        Set the command to call on a single click.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def current(self, val='True', **kwargs):
        """
        Set this button to display as the current layer.  The current layer is the one which the user has the option of adding all newly created objects into.  NB: Setting the layer button to this state has no effect on the actual current layer.
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def doubleClickCommand(self, val='True', **kwargs):
        """
        Set the command to call on a double click.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getIdentification(self, **kwargs):
        """
        This is the integer identification number associated with the layer.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label text for the button.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getLabelWidth(self, **kwargs):
        """
        Query the width of the label part so as to determine if button clicks are in the label part or the colour swatch part.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getLayerHideOnPlayback(self, **kwargs):
        """
        Indicates whether the layer is visible or invisible during the playback.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getLayerState(self, **kwargs):
        """
        Describes the state of the layer.  This may be one of normal, template, or reference.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getLayerVisible(self, **kwargs):
        """
        Indicates whether the layer is visible or invisible.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Set this button to display as a selected layer.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getTransparent(self, **kwargs):
        """
        Indicate whether the layer color is visible or transparent.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def hideOnPlaybackCommand(self, val='True', **kwargs):
        """
        Command that is called when the hide on playback indicator of the layer button is pressed.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def renameCommand(self, val='True', **kwargs):
        """
        Set the command to call when the layer gets renamed. The string '#1' will be substituted with the control's name and '#2' will be replaced with the layer's new name.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setIdentification(self, val='True', **kwargs):
        """
        This is the integer identification number associated with the layer.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label text for the button.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setLayerHideOnPlayback(self, val='True', **kwargs):
        """
        Indicates whether the layer is visible or invisible during the playback.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setLayerState(self, val='True', **kwargs):
        """
        Describes the state of the layer.  This may be one of normal, template, or reference.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setLayerVisible(self, val='True', **kwargs):
        """
        Indicates whether the layer is visible or invisible.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Set this button to display as a selected layer.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setTransparent(self, val='True', **kwargs):
        """
        Indicate whether the layer color is visible or transparent.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def typeCommand(self, val='True', **kwargs):
        """
        Command that is called when the type indicator of the layer button is pressed.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    def visibleCommand(self, val='True', **kwargs):
        """
        Command that is called when the visibility indicator of the layer button is pressed.                  
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Creates a layer bar button widget.  This widget contains both the name of the
        layer to which it refers and a color swatch indicating it's color assignment.
        It is used primarily in the construction of the layerBar and layer Editor
        window, being the widget used for each layer in the respective lists.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Set the command to call on a change of any kind.
        
        - color : cl                     (float, float, float) [create,edit]
            Layer color, specified with normalized real numbers in R, G, B space.
        
        - command : c                    (script)        [create,edit]
            Set the command to call on a single click.
        
        - current : cr                   (bool)          [create,edit]
            Set this button to display as the current layer.  The current layer is the one
            which the user has the option of adding all newly created objects into.  NB:
            Setting the layer button to this state has no effect on the actual current
            layer.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,edit]
            Set the command to call on a double click.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - hideOnPlaybackCommand : hpc    (script)        [create,edit]
            Command that is called when the hide on playback indicator of the layer button
            is pressed.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - identification : id            (int)           [create,query,edit]
            This is the integer identification number associated with the layer.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Label text for the button.
        
        - labelWidth : lw                (bool)          [query]
            Query the width of the label part so as to determine if button clicks are in the
            label part or the colour swatch part.
        
        - layerHideOnPlayback : hp       (bool)          [create,query,edit]
            Indicates whether the layer is visible or invisible during the playback.
        
        - layerState : ls                (unicode)       [create,query,edit]
            Describes the state of the layer.  This may be one of normal, template, or
            reference.
        
        - layerVisible : lv              (bool)          [create,query,edit]
            Indicates whether the layer is visible or invisible.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - name : n                       (unicode)       [create,query]
            Name of the layer.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - renameCommand : rc             (unicode)       [create,edit]
            Set the command to call when the layer gets renamed. The string '#1' will be
            substituted with the control's name and '#2' will be replaced with the layer's
            new name.
        
        - select : s                     (bool)          [create,query,edit]
            Set this button to display as a selected layer.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - transparent : t                (bool)          [create,query,edit]
            Indicate whether the layer color is visible or transparent.
        
        - typeCommand : tc               (script)        [create,edit]
            Command that is called when the type indicator of the layer button is pressed.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - visibleCommand : vc            (script)        [create,edit]
            Command that is called when the visibility indicator of the layer button is
            pressed.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.layerButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'layerButton'
    
    
    __melui__ = 'layerButton'


class AttrEnumOptionMenu(PyUI):
    def attribute(self, val='True', **kwargs):
        """
        Attribute that the menu controls.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        The command string is executed when the value of the option menu changes.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The label text.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The label text.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates an enumerated attribute control. It is usually an option
        menu.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attribute : at                 (PyNode)        [create,edit]
            Attribute that the menu controls.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            The command string is executed when the value of the option menu changes.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enumeratedItem : ei            (int, unicode)  [create]
            Enumerated item and the corresponding string.  If this flag is not supplied when
            the control is created, then the command will try to read the values from the
            attribute.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The label text.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenu`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attrEnumOptionMenu'
    
    
    __melui__ = 'attrEnumOptionMenu'


class CommandMenuItem(PyUI):
    def __enter__(self): pass
    def __exit__(self, type, value, traceback): pass
    def getAllowOptionBoxes(self, **kwargs):
        """
        Deprecated. All menus and menu items always allow option boxes. In the case of submenu items this flag specifies whether the submenu will be able to support option box menu items. Always returns true.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the menu item with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getBoldFont(self, **kwargs):
        """
        Specify if text should be bold. Only supported in menus which use the marking menu implementation.  Default is false for Windows, and true for all other platforms.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getCheckBox(self, **kwargs):
        """
        Creates a check box menu item.  Argument specifies the check box value.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getCollection(self, **kwargs):
        """
        To explicitly add a radio menu item to a radioMenuItemCollection.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Attaches a command/script that will be executed when the item is selected. Note this command is not executed when the menu item is in an optionMenucontrol.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getData(self, **kwargs):
        """
        Attaches a piece of user-defined data to the menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getDivider(self, **kwargs):
        """
        Creates a divider menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getDividerLabel(self, **kwargs):
        """
        Adds a label to a divider menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getDragDoubleClickCommand(self, **kwargs):
        """
        If the menu item is put on the shelf then this command will be invoked when the corresponding shelf object is double clicked.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getDragMenuCommand(self, **kwargs):
        """
        If the menu item is put on the shelf then this command will be invoked when the corresponding shelf object is clicked.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getEchoCommand(self, **kwargs):
        """
        Specify whether the action attached with the c/commandflag should echo to the command output areas when invoked. This flag is false by default and must be specified with the c/commandflag.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getEnable(self, **kwargs):
        """
        Enable state for the menu item.  A disabled menu item is dimmed and unresponsive.  An enabled menu item is selectable and has normal appearance.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getEnableCommandRepeat(self, **kwargs):
        """
        This flag only affects menu items to which a command can be attached.  Specify true and the command may be repeated by executing the command repeatLast.  This flag is true by default for all items except for option box items.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getFamilyImage(self, **kwargs):
        """
        Get the filename of the family icon associated with the menu. The family icon will be used for the shelf unless an icon is specified with the imageflag.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getImage(self, **kwargs):
        """
        The filename of the icon associated with the menu item.  If the menu containing the menu item is being edited with a menuEditor widget, then the menuEditor will use this icon to represent the menu item. This icon will be displayed on the shelf when the menu item is placed there.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        Specify a short (5 character) text string to be overlayed on top of the icon associated with the menu item. This is primarily a mechanism for differentiating menu items that are using a Family icon due to the fact that an icon image had not been explicitly defined. The image overlay label will not be used if an icon image is defined for the menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getIsCheckBox(self, **kwargs):
        """
        Returns true if the item is a check box item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getIsOptionBox(self, **kwargs):
        """
        Returns true if the item is an option box item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getIsRadioButton(self, **kwargs):
        """
        Returns true if the item is a radio button item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getItalicized(self, **kwargs):
        """
        Specify if text should be italicized. Only supported in menus which use the marking menu implementation.  Default is false.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that appears in the item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getLongDivider(self, **kwargs):
        """
        Indicate whether the divider is long or short. Has no effect if divider label is set. Default is true.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getOptionBox(self, **kwargs):
        """
        Indicates that the menu item will be an option box item.  This item will appear to the right of the preceeding menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getOptionBoxIcon(self, **kwargs):
        """
        The filename of an icon to be used instead of the usual option box icon. The icon is searched for in the folder specified by the XBMLANGPATH environment variable. The icon can be any size, but will be resized to the standard 16x16 pixels when drawn.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getPostMenuCommand(self, **kwargs):
        """
        Specify a script to be executed when the submenu is about to be shown.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getPostMenuCommandOnce(self, **kwargs):
        """
        Indicate the pmc/postMenuCommandshould only be invoked once.  Default value is false, ie. the pmc/postMenuCommandis invoked everytime the sub menu is shown.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getRadialPosition(self, **kwargs):
        """
        The radial position of the menu item if it is in a Marking Menu.  Radial positions are given in the form of a cardinal direction, and may be N, NW, W, SW, S, SE, Eor NE.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getRadioButton(self, **kwargs):
        """
        Creates a radio button menu item.  Argument specifies the radio button value.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getSourceType(self, **kwargs):
        """
        Set the language type for a command script. Can only be used in conjunction with a command flag.  Without this flag, commands are assumed to be the same language of the executing script.  In query mode, will return the language of the specified command. Valid values are meland python.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getSubMenu(self, **kwargs):
        """
        Indicates that the item will have a submenu. Subsequent menuItems will be added to the submenu until setParent -menuis called.  Note that a submenu item creates a menu object and consequently the menucommand may be used on the submenu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        For the case where the menu item is a sub menu this flag will make the sub menu tear-off-able. Note that this flag has no effect on the other menu item types.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this menu item feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def runTimeCommand(self, val='True', **kwargs):
        """
        A shortcut flag to link the menu item with a runTimeCommand. The value is the name of the runTimeCommand (unique). It copies the following fields from the runTimeCommand if those fields have not been provided to this command: label, annotation, image, command. Note: command will be set to the runTimeCommand itself.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the menu item with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setCheckBox(self, val='True', **kwargs):
        """
        Creates a check box menu item.  Argument specifies the check box value.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        Attaches a command/script that will be executed when the item is selected. Note this command is not executed when the menu item is in an optionMenucontrol.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setData(self, val='True', **kwargs):
        """
        Attaches a piece of user-defined data to the menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setDividerLabel(self, val='True', **kwargs):
        """
        Adds a label to a divider menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setDragDoubleClickCommand(self, val='True', **kwargs):
        """
        If the menu item is put on the shelf then this command will be invoked when the corresponding shelf object is double clicked.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setDragMenuCommand(self, val='True', **kwargs):
        """
        If the menu item is put on the shelf then this command will be invoked when the corresponding shelf object is clicked.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setEchoCommand(self, val='True', **kwargs):
        """
        Specify whether the action attached with the c/commandflag should echo to the command output areas when invoked. This flag is false by default and must be specified with the c/commandflag.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        Enable state for the menu item.  A disabled menu item is dimmed and unresponsive.  An enabled menu item is selectable and has normal appearance.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setEnableCommandRepeat(self, val='True', **kwargs):
        """
        This flag only affects menu items to which a command can be attached.  Specify true and the command may be repeated by executing the command repeatLast.  This flag is true by default for all items except for option box items.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        The filename of the icon associated with the menu item.  If the menu containing the menu item is being edited with a menuEditor widget, then the menuEditor will use this icon to represent the menu item. This icon will be displayed on the shelf when the menu item is placed there.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        Specify a short (5 character) text string to be overlayed on top of the icon associated with the menu item. This is primarily a mechanism for differentiating menu items that are using a Family icon due to the fact that an icon image had not been explicitly defined. The image overlay label will not be used if an icon image is defined for the menu item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that appears in the item.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setLongDivider(self, val='True', **kwargs):
        """
        Indicate whether the divider is long or short. Has no effect if divider label is set. Default is true.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setOptionBoxIcon(self, val='True', **kwargs):
        """
        The filename of an icon to be used instead of the usual option box icon. The icon is searched for in the folder specified by the XBMLANGPATH environment variable. The icon can be any size, but will be resized to the standard 16x16 pixels when drawn.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setPostMenuCommand(self, val='True', **kwargs):
        """
        Specify a script to be executed when the submenu is about to be shown.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setPostMenuCommandOnce(self, val='True', **kwargs):
        """
        Indicate the pmc/postMenuCommandshould only be invoked once.  Default value is false, ie. the pmc/postMenuCommandis invoked everytime the sub menu is shown.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setRadialPosition(self, val='True', **kwargs):
        """
        The radial position of the menu item if it is in a Marking Menu.  Radial positions are given in the form of a cardinal direction, and may be N, NW, W, SW, S, SE, Eor NE.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setRadioButton(self, val='True', **kwargs):
        """
        Creates a radio button menu item.  Argument specifies the radio button value.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setSourceType(self, val='True', **kwargs):
        """
        Set the language type for a command script. Can only be used in conjunction with a command flag.  Without this flag, commands are assumed to be the same language of the executing script.  In query mode, will return the language of the specified command. Valid values are meland python.                  
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this menu item feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries menu items.
        
        Flags:
        - allowOptionBoxes : aob         (bool)          [create,query]
            Deprecated. All menus and menu items always allow option boxes. In the case of
            submenu items this flag specifies whether the submenu will be able to support
            option box menu items. Always returns true.
        
        - altModifier : alt              (bool)          []
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the menu item with an extra string value.
        
        - boldFont : bld                 (bool)          [create,query]
            Specify if text should be bold. Only supported in menus which use the marking
            menu implementation.  Default is false for Windows, and true for all other
            platforms.
        
        - checkBox : cb                  (bool)          [create,query,edit]
            Creates a check box menu item.  Argument specifies the check box value.
        
        - collection : cl                (unicode)       [create,query]
            To explicitly add a radio menu item to a radioMenuItemCollection.
        
        - command : c                    (script)        [create,query,edit]
            Attaches a command/script that will be executed when the item is selected. Note
            this command is not executed when the menu item is in an optionMenucontrol.
        
        - commandModifier : cmd          (bool)          []
        
        - ctrlModifier : ctl             (bool)          []
        
        - data : da                      (int)           [create,query,edit]
            Attaches a piece of user-defined data to the menu item.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - divider : d                    (bool)          [create,query]
            Creates a divider menu item.
        
        - dividerLabel : dl              (unicode)       [create,query,edit]
            Adds a label to a divider menu item.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the menu item.
        
        - dragDoubleClickCommand : ddc   (script)        [create,query,edit]
            If the menu item is put on the shelf then this command will be invoked when the
            corresponding shelf object is double clicked.
        
        - dragMenuCommand : dmc          (script)        [create,query,edit]
            If the menu item is put on the shelf then this command will be invoked when the
            corresponding shelf object is clicked.
        
        - echoCommand : ec               (bool)          [create,query,edit]
            Specify whether the action attached with the c/commandflag should echo to the
            command output areas when invoked. This flag is false by default and must be
            specified with the c/commandflag.
        
        - enable : en                    (bool)          [create,query,edit]
            Enable state for the menu item.  A disabled menu item is dimmed and
            unresponsive.  An enabled menu item is selectable and has normal appearance.
        
        - enableCommandRepeat : ecr      (bool)          [create,query,edit]
            This flag only affects menu items to which a command can be attached.  Specify
            true and the command may be repeated by executing the command repeatLast.  This
            flag is true by default for all items except for option box items.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - familyImage : fi               (unicode)       [query]
            Get the filename of the family icon associated with the menu. The family icon
            will be used for the shelf unless an icon is specified with the imageflag.
        
        - image : i                      (unicode)       [create,query,edit]
            The filename of the icon associated with the menu item.  If the menu containing
            the menu item is being edited with a menuEditor widget, then the menuEditor will
            use this icon to represent the menu item. This icon will be displayed on the
            shelf when the menu item is placed there.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            Specify a short (5 character) text string to be overlayed on top of the icon
            associated with the menu item. This is primarily a mechanism for differentiating
            menu items that are using a Family icon due to the fact that an icon image had
            not been explicitly defined. The image overlay label will not be used if an icon
            image is defined for the menu item.
        
        - insertAfter : ia               (unicode)       [create]
            Specify After which item the new one will be placed. If this flag is not
            specified, item is added at the end of the menu. Use the empty string to insert
            before the first item of the menu.
        
        - isCheckBox : icb               (bool)          [query]
            Returns true if the item is a check box item.
        
        - isOptionBox : iob              (bool)          [query]
            Returns true if the item is an option box item.
        
        - isRadioButton : irb            (bool)          [query]
            Returns true if the item is a radio button item.
        
        - italicized : itl               (bool)          [create,query]
            Specify if text should be italicized. Only supported in menus which use the
            marking menu implementation.  Default is false.
        
        - keyEquivalent : ke             (unicode)       []
        
        - label : l                      (unicode)       [create,query,edit]
            The text that appears in the item.
        
        - longDivider : ld               (bool)          [create,query,edit]
            Indicate whether the divider is long or short. Has no effect if divider label is
            set. Default is true.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - mnemonic : mn                  (unicode)       []
        
        - optionBox : ob                 (bool)          [create,query]
            Indicates that the menu item will be an option box item.  This item will appear
            to the right of the preceeding menu item.
        
        - optionBoxIcon : obi            (unicode)       [create,query,edit]
            The filename of an icon to be used instead of the usual option box icon. The
            icon is searched for in the folder specified by the XBMLANGPATH environment
            variable. The icon can be any size, but will be resized to the standard 16x16
            pixels when drawn.
        
        - optionModifier : opt           (bool)          []
        
        - parent : p                     (unicode)       [create]
            Specify the menu that the item will appear in.
        
        - postMenuCommand : pmc          (script)        [create,query,edit]
            Specify a script to be executed when the submenu is about to be shown.
        
        - postMenuCommandOnce : pmo      (bool)          [create,query,edit]
            Indicate the pmc/postMenuCommandshould only be invoked once.  Default value is
            false, ie. the pmc/postMenuCommandis invoked everytime the sub menu is shown.
        
        - radialPosition : rp            (unicode)       [create,query,edit]
            The radial position of the menu item if it is in a Marking Menu.  Radial
            positions are given in the form of a cardinal direction, and may be N, NW, W,
            SW, S, SE, Eor NE.
        
        - radioButton : rb               (bool)          [create,query,edit]
            Creates a radio button menu item.  Argument specifies the radio button value.
        
        - runTimeCommand : rtc           (unicode)       [create,edit]
            A shortcut flag to link the menu item with a runTimeCommand. The value is the
            name of the runTimeCommand (unique). It copies the following fields from the
            runTimeCommand if those fields have not been provided to this command: label,
            annotation, image, command. Note: command will be set to the runTimeCommand
            itself.
        
        - shiftModifier : sh             (bool)          []
        
        - sourceType : stp               (unicode)       [create,query,edit]
            Set the language type for a command script. Can only be used in conjunction with
            a command flag.  Without this flag, commands are assumed to be the same language
            of the executing script.  In query mode, will return the language of the
            specified command. Valid values are meland python.
        
        - subMenu : sm                   (bool)          [create,query]
            Indicates that the item will have a submenu. Subsequent menuItems will be added
            to the submenu until setParent -menuis called.  Note that a submenu item creates
            a menu object and consequently the menucommand may be used on the submenu item.
        
        - tearOff : to                   (bool)          [create,query]
            For the case where the menu item is a sub menu this flag will make the sub menu
            tear-off-able. Note that this flag has no effect on the other menu item types.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this menu item feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.menuItem`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'menuItem'
    
    
    __melui__ = 'menuItem'


class HyperShade(PyUI):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Commands for shader editing in the hypergraph
        
        Flags:
        - assign : a                     (unicode)       [create]
            Assign the specified shader node to renderable objects on the active list. The
            node can either be a shading group or the shader node attached to the shading
            group.
        
        - clearWorkArea : cwa            (bool)          [create]
            Push the current work area on to the stack and create a clear work area
        
        - collapse : clp                 (unicode)       [create]
            Hide the upstream nodes from the specified node.
        
        - createNode : rcn               (unicode)       [create]
            Create a node of the specified type.  This is called when a new rendering node
            is created using drag and drop from the image browser or from the RMB context
            sensitive menu on nodes in the Visor Create folders.
        
        - dependGraphArea : dg           (bool)          [create]
            When setting a work area, and the work area doesn't already exist this flag
            inicates a new graph should be created that is either a depend graph or a folder
            view.
        
        - downStream : ds                (bool)          [create]
            Show nodes downstream from the specified node
        
        - duplicate : dup                (bool)          [create]
            Duplicate upstream nodes.  If the node is a shader make sure duplicate include
            the shading group if there is one
        
        - fixRenderSize : fix            (bool)          [create]
            If set to true dont rerender swatches when they change size as the user zooms
        
        - incremental : inc              (bool)          [create]
            Enable or disable incremental layout when making new nodes or connections
        
        - listDownstreamNodes : ldn      (PyNode)        [create]
            List all the downstream render nodes from the specified nodes.
        
        - listDownstreamShaderNodes : lds (PyNode)        [create]
            List all the downstream shader nodes from the specified nodes.
        
        - listUpstreamNodes : lun        (PyNode)        [create]
            List all the upstream render nodes from the specified nodes.
        
        - name : n                       (unicode)       [create]
            Name for the work area created by this command
        
        - networks : net                 (bool)          [create]
            Do an incremental layout on all of the nodes in the current selection list and
            that are in the current work area.
        
        - noSGShapes : nsg               (bool)          [create]
            Display only shapes that are connected to nodes in the network other than a
            shading group.
        
        - noShapes : ns                  (bool)          [create]
            Display no shapes when graphing networks.
        
        - noTransforms : nt              (bool)          [create]
            Display no transforms when graphing networks.
        
        - objects : o                    (unicode)       [create]
            Select the objects which are attached to the specified shader node. The shader
            node can be either the shading group or the shader attached to the shading
            group.  When this flag's argument is the empty string, we will use the currently
            selected shder node as the input.
        
        - renderCreateAndDrop : rcd      (unicode)       [create]
            Create a render node of the specified type and put user into drag and drop mode
            to place or connect it.
        
        - reset : rst                    (bool)          [create]
            Reset the Hypershade panel to its initial state.  In particular delete all the
            work areas.
        
        - resetGraph : rsg               (bool)          [create]
            Reset the current graph.  Typically called prior to rebuilding a folder in a
            Hypershade view.
        
        - resetSwatch : rss              (bool)          [create]
            For all selected nodes remove user defined swatches if the node has one
        
        - setAllowsRegraphing : sar      (bool)          [create]
            For internal use only.
        
        - setWorkArea : swa              (unicode)       [create]
            Set the work area to the existing named work area
        
        - shaderNetwork : sn             (unicode)       [create]
            Show the shader network for the specified material node.  If the materials
            shading group has a displacement or volume map these will be shown.  If not then
            the shading group will not be shown.
        
        - shaderNetworks : sns           (bool)          [create]
            Show the shader network for all the objects on the selection list that have
            shaders.
        
        - shaderNetworksSelectMaterialNodes : smn (bool)          [create]
            Select the material nodes in the shader network for all the objects on the
            selection list that have shaders.
        
        - snapShot : snp                 (bool)          [create]
            Put hypergraph in snapshot mode.  This is only for testing
        
        - uncollapse : ucl               (unicode)       [create]
            Unhide the upstream nodes from the specified node.
        
        - upStream : ups                 (bool)          [create]
            Show nodes upstream from the specified node
        
        - userDefinedLayout : udl        (bool)          [create]
            Enable or disable remembrance of user defined layouts.  Default is disabled
            until this functionality is better tested.
        
        - workAreaAddCmd : waa           (unicode)       [create]
            Set the MEL procedure called when a new work area is added to HyperShade
        
        - workAreaDeleteCmd : wad        (unicode)       [create]
            Set the MEL procedure called when a work area is deleted in HyperShade
        
        - workAreaSelectCmd : was        (unicode)       [create]
            Set the MEL procedure called when a work area is selected in HyperShade
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.hyperShade`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'hyperShade'
    
    
    __melui__ = 'hyperShade'


class Canvas(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getHsvValue(self, **kwargs):
        """
        Three float values corresponding to the hue, saturation, and value color components, where the hue value ranges from 0.0 to 360.0 and the saturation and value components range from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getRgbValue(self, **kwargs):
        """
        Three float values corresponding to the red, green, and blue color components, all of which range from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def pressCommand(self, val='True', **kwargs):
        """
        Command to be executed when there is a mouse press.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setHsvValue(self, val='True', **kwargs):
        """
        Three float values corresponding to the hue, saturation, and value color components, where the hue value ranges from 0.0 to 360.0 and the saturation and value components range from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setRgbValue(self, val='True', **kwargs):
        """
        Three float values corresponding to the red, green, and blue color components, all of which range from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Creates a control capable of displaying a color swatch. This control can also
        accept a command to be called when the colour swatch is pressed by the user.
        Note: The -dgc/dragCallback and -dpc/dropCallback are not available for this
        control.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - hsvValue : hsv                 (float, float, float) [create,query,edit]
            Three float values corresponding to the hue, saturation, and value color
            components, where the hue value ranges from 0.0 to 360.0 and the saturation and
            value components range from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - pressCommand : pc              (script)        [create,edit]
            Command to be executed when there is a mouse press.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rgbValue : rgb                 (float, float, float) [create,query,edit]
            Three float values corresponding to the red, green, and blue color components,
            all of which range from 0.0 to 1.0.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.canvas`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'canvas'
    
    
    __melui__ = 'canvas'


class Visor(PyUI):
    def getAddFolder(self, **kwargs):
        """
        Add a new folder to the current visual browser                             
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getAddNodes(self, **kwargs):
        """
        Add dependency graph nodes by name to a user defined custom folder.  The argument is a string encolsed in quotes with 1 one more node names seperated by blanks                                    
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getAllowPanningInX(self, **kwargs):
        """
        Specifies whether or not the user should be able to pan the contents of the visor horizontally. Default is true.                                   
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getAllowPanningInY(self, **kwargs):
        """
        Specifies whether or not the user should be able to pan the contents of the visor vertically. Default is true.                             
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getAllowZooming(self, **kwargs):
        """
        Specifies whether or not the user should be able to zoom the contents of the visor. Default is true.                               
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Mel command which will return a list of nodes to add to a folder                                   
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getDeleteFolder(self, **kwargs):
        """
        Delete the specified folder and all of its children                                
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getEditFolder(self, **kwargs):
        """
        Edit the name and MEL command for an existing folder                               
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getFolderList(self, **kwargs):
        """
        Return a string array of the folders in the visor.                                 
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getMenu(self, **kwargs):
        """
        Set the name of the script to run to get a popup menu                              
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getNodeType(self, **kwargs):
        """
        A node type used by folders of type nodeTypeInDAG                                  
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getOpenDirectories(self, **kwargs):
        """
        When adding a new folder indicate if it sub directories will be show. The default is to not show sub directories.                                  
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getOpenFolder(self, **kwargs):
        """
        When adding a new folder indicate if it will be open or closed by default. The default is closed.                                  
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getPath(self, **kwargs):
        """
        Path to a file system directory to be displayed in the folder                              
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getPopupMenuScript(self, **kwargs):
        """
        Specifies the script to be called when the right mouse button is pressed in the visor. The name of the editor in which the right mouse button was pressed will be appended to the script at the time the script is called.                                 
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getRebuild(self, **kwargs):
        """
        Rebuild the visor after interactively adding a folder                              
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getRefreshAllSwatches(self, **kwargs):
        """
        Refresh the swatches of all files currently displayed in this visor.                               
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getRefreshSelectedSwatches(self, **kwargs):
        """
        Refresh the swatches of all files currently selected in any visor.                                 
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getRefreshSwatch(self, **kwargs):
        """
        Refresh the swatch of the file with the specified path.                                    
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getReset(self, **kwargs):
        """
        Clear all previously loaded folder descriptions in preperation for building a new visual browser                                   
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getRestrictPanAndZoom(self, **kwargs):
        """
        Specifies whether the panning and zooming of the visor should be restricted to keep the contents in the top left corner of the visor when they are smaller than the visible area within the visor. Default is true.                                
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getSaveSwatches(self, **kwargs):
        """
        Save swatches to disk for currently displayed image files.                                 
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getScrollBar(self, **kwargs):
        """
        Set the name of the scroll bar associated with visor                               
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getScrollPercent(self, **kwargs):
        """
        Set the percentage value for the scroll bar.  Typically called from a a scroll bars callback.                              
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getSelectedGadgets(self, **kwargs):
        """
        Return a string array of the currently selected gadgets (files, folders, nodes) in the visor.                              
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getShowDividers(self, **kwargs):
        """
        Specifies whether or not the visor should show dividers. The default is true. If -showDividers is set to false, dividers will be drawn as folders instead.                                 
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getShowFiles(self, **kwargs):
        """
        Specifies whether or not the visor should show files. The default is true.                                 
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getShowFolders(self, **kwargs):
        """
        Specifies whether or not the visor should show folders. The default is true.                               
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getShowNodes(self, **kwargs):
        """
        Specifies whether or not the visor should show nodes. The default is true.                                 
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Return the MEL command string to save the folder setup in visor                                    
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getStyle(self, **kwargs):
        """
        Set display style for the browser.  Options are:     outliner          A single column with an outliner style icon and a text label     singleColumn          A single column with an image style icon and a text label     multiColumn          A multiple column grid of swatches with the text label below the swatch                                   
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getTransform(self, **kwargs):
        """
        Name of a transform node used by folders of type nodeTypeInDAG                             
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    def getType(self, **kwargs):
        """
        Type of the new folder.  Options are: command A mel command that will return a list of depend nodes that will          be displayed in the folderconnectedNodes The nodes connected to the specified node name will be displayed          in the folderdefaultNodes A mel command that will generate default node types.  These nodes          will not be part of the scene and are used for drag and drop          creation of new nodes that are in the scene.  The mel command          use with this type is usually listNodetypes.directory A directory name in the file systemdirectoryCommand A mel command that will return a directory name in the file systemfolder An empty folder(the default value).  Empty folders can be used         as user defined folders by dropping dependency graph nodes in to themnodeTypeInDAG List all nodes of a given type under a specified transforms in the                 DAG.  For example list all the shaders for a character by specifying         the top transform of the charactershelfItems A directory containing mel files to use as shelf itemsFlag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Command for the creation and manipulation of a Visor UI element. The Visor is
        used to display the contents of a scene (rendering related nodes in particular),
        as well as files on disk which the user may wish to bring into the scene (shader
        and texture libraries for example).
        
        Flags:
        - addFolder : add                (bool)          [create,query]
            Add a new folder to the current visual browser
        
        - addNodes : adn                 (unicode)       [create,query]
            Add dependency graph nodes by name to a user defined custom folder.  The
            argument is a string encolsed in quotes with 1 one more node names seperated by
            blanks
        
        - allowPanningInX : apx          (bool)          [create,query]
            Specifies whether or not the user should be able to pan the contents of the
            visor horizontally. Default is true.
        
        - allowPanningInY : apy          (bool)          [create,query]
            Specifies whether or not the user should be able to pan the contents of the
            visor vertically. Default is true.
        
        - allowZooming : az              (bool)          [create,query]
            Specifies whether or not the user should be able to zoom the contents of the
            visor. Default is true.
        
        - command : cmd                  (unicode)       [create,query]
            Mel command which will return a list of nodes to add to a folder
        
        - deleteFolder : deleteFolder    (unicode)       [create,query]
            Delete the specified folder and all of its children
        
        - editFolder : edf               (unicode)       [create,query]
            Edit the name and MEL command for an existing folder
        
        - folderList : fl                (unicode)       [query]
            Return a string array of the folders in the visor.
        
        - menu : mn                      (unicode)       [create,query]
            Set the name of the script to run to get a popup menu
        
        - name : n                       (unicode)       [create,query]
            Name of the new folder
        
        - nodeType : ntp                 (unicode)       [create,query]
            A node type used by folders of type nodeTypeInDAG
        
        - openDirectories : opd          (bool)          [create,query]
            When adding a new folder indicate if it sub directories will be show. The
            default is to not show sub directories.
        
        - openFolder : opf               (bool)          [create,query]
            When adding a new folder indicate if it will be open or closed by default. The
            default is closed.
        
        - parent : p                     (unicode)       [create,query]
            Parent folder of this folder
        
        - path : pth                     (unicode)       [create,query]
            Path to a file system directory to be displayed in the folder
        
        - popupMenuScript : pms          (unicode)       [create,query]
            Specifies the script to be called when the right mouse button is pressed in the
            visor. The name of the editor in which the right mouse button was pressed will
            be appended to the script at the time the script is called.
        
        - rebuild : re                   (bool)          [create,query]
            Rebuild the visor after interactively adding a folder
        
        - refreshAllSwatches : ras       (bool)          [create,query]
            Refresh the swatches of all files currently displayed in this visor.
        
        - refreshSelectedSwatches : rss  (bool)          [create,query]
            Refresh the swatches of all files currently selected in any visor.
        
        - refreshSwatch : rs             (unicode)       [create,query]
            Refresh the swatch of the file with the specified path.
        
        - reset : rst                    (bool)          [create,query]
            Clear all previously loaded folder descriptions in preperation for building a
            new visual browser
        
        - restrictPanAndZoom : rpz       (bool)          [create,query]
            Specifies whether the panning and zooming of the visor should be restricted to
            keep the contents in the top left corner of the visor when they are smaller than
            the visible area within the visor. Default is true.
        
        - saveSwatches : ss              (bool)          [create,query]
            Save swatches to disk for currently displayed image files.
        
        - scrollBar : sb                 (unicode)       [create,query]
            Set the name of the scroll bar associated with visor
        
        - scrollPercent : sp             (float)         [create,query]
            Set the percentage value for the scroll bar.  Typically called from a a scroll
            bars callback.
        
        - selectedGadgets : sg           (unicode)       [query]
            Return a string array of the currently selected gadgets (files, folders, nodes)
            in the visor.
        
        - showDividers : sd              (bool)          [create,query]
            Specifies whether or not the visor should show dividers. The default is true. If
            -showDividers is set to false, dividers will be drawn as folders instead.
        
        - showFiles : sfi                (bool)          [create,query]
            Specifies whether or not the visor should show files. The default is true.
        
        - showFolders : sfo              (bool)          [create,query]
            Specifies whether or not the visor should show folders. The default is true.
        
        - showNodes : sn                 (bool)          [create,query]
            Specifies whether or not the visor should show nodes. The default is true.
        
        - stateString : sts              (bool)          [create,query]
            Return the MEL command string to save the folder setup in visor
        
        - style : stl                    (unicode)       [create,query]
            Set display style for the browser.  Options are:     outliner          A single
            column with an outliner style icon and a text label     singleColumn          A
            single column with an image style icon and a text label     multiColumn
            A multiple column grid of swatches with the text label below the swatch
        
        - transform : trn                (unicode)       [create,query]
            Name of a transform node used by folders of type nodeTypeInDAG
        
        - type : typ                     (unicode)       [create,query]
            Type of the new folder.  Options are: command A mel command that will return a
            list of depend nodes that will          be displayed in the folderconnectedNodes
            The nodes connected to the specified node name will be displayed          in the
            folderdefaultNodes A mel command that will generate default node types.  These
            nodes          will not be part of the scene and are used for drag and drop
            creation of new nodes that are in the scene.  The mel command          use with
            this type is usually listNodetypes.directory A directory name in the file
            systemdirectoryCommand A mel command that will return a directory name in the
            file systemfolder An empty folder(the default value).  Empty folders can be used
            as user defined folders by dropping dependency graph nodes in to
            themnodeTypeInDAG List all nodes of a given type under a specified transforms in
            the                 DAG.  For example list all the shaders for a character by
            specifying         the top transform of the charactershelfItems A directory
            containing mel files to use as shelf itemsFlag can have multiple arguments,
            passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.visor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'visor'
    
    
    __melui__ = 'visor'


class ShelfButton(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getAlign(self, **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Command executed when the control is pressed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getCommandRepeatable(self, **kwargs):
        """
        Set if the MEL command specified in the command flag should be repeatable or not.  The gkey, by default, is the shortcut to repeat the last executed command.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getDisabledImage(self, **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getDoubleClickCommand(self, **kwargs):
        """
        Command executed when the control is double clicked.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getEnableCommandRepeat(self, **kwargs):
        """
        This flag only affects menu items to which a command can be attached.  Specify true and the command may be repeated by executing the command repeatLast.  This flag is true by default for all items except for option box items.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getFlat(self, **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getFlexibleWidthType(self, **kwargs):
        """
        This flag is used to have the shelf button have a wider or thinner width. The valid values are: Standard = 1, Custom = 2, Automatic = 3. The Standard type will resize, keeping the aspect ratio, to 32x32 pixels. The Automatic type will adjust the button width to make sure wide images are used properly. The Custom type will allow the user to choose the desired width for the icon. Default value is 3.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getFlexibleWidthValue(self, **kwargs):
        """
        This flag is only useful when the Custom flexibleWidthTypeis chosen. The value is a width in pixels.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getFlipX(self, **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getFlipY(self, **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getHighlightImage(self, **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getImage(self, **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getImage1(self, **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getImage2(self, **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getImage3(self, **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getLabelOffset(self, **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getMarginHeight(self, **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getMarginWidth(self, **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getOverlayLabelBackColor(self, **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getOverlayLabelColor(self, **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getRotation(self, **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getSelectionImage(self, **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getSourceType(self, **kwargs):
        """
        Sets the language type for the command script. Can only be used in conjunction with the c/command or dcc/doubleClickCommand flags. Valid values are mel(enabled by default), and python.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getStyle(self, **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getUseAlpha(self, **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def handleNodeDropCallback(self, val='True', **kwargs):
        """
        Specify a script callback which is called when a node is dropped on the control.  The name of the node being dropped will be passed to the function  (python callable) or appended to the end (script) to form the command to be executed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def labelEditingCallback(self, val='True', **kwargs):
        """
        Specify a callback which is called after the user double clicks the label of the control to give it a new label. The new label string will be passed to the callback.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def menuItem(self, val='True', **kwargs):
        """
        Creates menu items for this button by passing in arguments for the menu item label and command for each item.  These should be passed as strings: labelcommandfor each use of this flag in the command.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def menuItemPython(self, val='True', **kwargs):
        """
        This flag is used to specify that a menu item is in Python. The integer value is the index of the menuItem that is modified by this flag. This is 0 based, so it corresponds to the (index+1)th occurrence of the /-mi/-menuItemflag.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def scaleIcon(self, val='True', **kwargs):
        """
        For textOnlyand iconOnlystyle, this flag has no effect. For other styles, if the flag is specified, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        Command executed when the control is pressed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setCommandRepeatable(self, val='True', **kwargs):
        """
        Set if the MEL command specified in the command flag should be repeatable or not.  The gkey, by default, is the shortcut to repeat the last executed command.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setDisabledImage(self, val='True', **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setDoubleClickCommand(self, val='True', **kwargs):
        """
        Command executed when the control is double clicked.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setEnableCommandRepeat(self, val='True', **kwargs):
        """
        This flag only affects menu items to which a command can be attached.  Specify true and the command may be repeated by executing the command repeatLast.  This flag is true by default for all items except for option box items.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setFlat(self, val='True', **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setFlexibleWidthType(self, val='True', **kwargs):
        """
        This flag is used to have the shelf button have a wider or thinner width. The valid values are: Standard = 1, Custom = 2, Automatic = 3. The Standard type will resize, keeping the aspect ratio, to 32x32 pixels. The Automatic type will adjust the button width to make sure wide images are used properly. The Custom type will allow the user to choose the desired width for the icon. Default value is 3.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setFlexibleWidthValue(self, val='True', **kwargs):
        """
        This flag is only useful when the Custom flexibleWidthTypeis chosen. The value is a width in pixels.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setFlipX(self, val='True', **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setFlipY(self, val='True', **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setHighlightImage(self, val='True', **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setImage1(self, val='True', **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setImage2(self, val='True', **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setImage3(self, val='True', **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setLabelOffset(self, val='True', **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setMarginHeight(self, val='True', **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setMarginWidth(self, val='True', **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setOverlayLabelBackColor(self, val='True', **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setOverlayLabelColor(self, val='True', **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setRotation(self, val='True', **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setSelectionImage(self, val='True', **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setSourceType(self, val='True', **kwargs):
        """
        Sets the language type for the command script. Can only be used in conjunction with the c/command or dcc/doubleClickCommand flags. Valid values are mel(enabled by default), and python.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setUseAlpha(self, val='True', **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This control supports up to 3 icon images and 4 different display styles.  The
        icon image displayed is the one that best fits the current size of the control
        given its current style. This command creates an iconTextButtonthat is designed
        to be on the shelf. The button contains a command that can be drag'n'dropped.
        
        Flags:
        - actionIsSubstitute : ais       (bool)          []
        
        - align : al                     (unicode)       [create,query,edit]
            The label alignment.  Alignment values are left, right, and center. By default,
            the label is aligned center. Currently only available when -st/style is set to
            iconAndTextCentered.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - command : c                    (script)        [create,query,edit]
            Command executed when the control is pressed.
        
        - commandRepeatable : rpt        (bool)          [create,query,edit]
            Set if the MEL command specified in the command flag should be repeatable or
            not.  The gkey, by default, is the shortcut to repeat the last executed command.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disabledImage : di             (unicode)       [create,query,edit]
            Image used when the button is disabled. Image size must be the same as the image
            specified with the i/imageflag. This is a Windows only flag.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,query,edit]
            Command executed when the control is double clicked.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableCommandRepeat : ecr      (bool)          [create,query,edit]
            This flag only affects menu items to which a command can be attached.  Specify
            true and the command may be repeated by executing the command repeatLast.  This
            flag is true by default for all items except for option box items.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - flat : fla                     (bool)          [create,query,edit]
            Sets whether the control will be a flat button (0 false, 1 true).
        
        - flexibleWidthType : fwt        (int)           [create,query,edit]
            This flag is used to have the shelf button have a wider or thinner width. The
            valid values are: Standard = 1, Custom = 2, Automatic = 3. The Standard type
            will resize, keeping the aspect ratio, to 32x32 pixels. The Automatic type will
            adjust the button width to make sure wide images are used properly. The Custom
            type will allow the user to choose the desired width for the icon. Default value
            is 3.
        
        - flexibleWidthValue : fwv       (int)           [create,query,edit]
            This flag is only useful when the Custom flexibleWidthTypeis chosen. The value
            is a width in pixels.
        
        - flipX : fx                     (bool)          [create,query,edit]
            Is the image flipped horizontally?
        
        - flipY : fy                     (bool)          [create,query,edit]
            Is the image flipped vertically?
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - handleNodeDropCallback : hnd   (script)        [create,edit]
            Specify a script callback which is called when a node is dropped on the control.
            The name of the node being dropped will be passed to the function  (python
            callable) or appended to the end (script) to form the command to be executed.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - highlightImage : hi            (unicode)       [create,query,edit]
            Highlight image displayed while the cursor is over the control. Image size must
            be the same as the image specified with the -i/imageflag. This is a Windows only
            flag.
        
        - image : i                      (unicode)       [create,query,edit]
            If you are not providing images with different sizes then you may use this flag
            for the control's image. If the iconOnlystyle is set, the icon will be scaled to
            the size of the control.
        
        - image1 : i1                    (unicode)       [create,query,edit]
            First of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image2 : i2                    (unicode)       [create,query,edit]
            Second of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image3 : i3                    (unicode)       [create,query,edit]
            Third of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            A short string, up to 6 characters, representing a label that will be displayed
            on top of the image.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The text that appears in the control.
        
        - labelEditingCallback : lec     (script)        [create,edit]
            Specify a callback which is called after the user double clicks the label of the
            control to give it a new label. The new label string will be passed to the
            callback.
        
        - labelOffset : lo               (int)           [create,query,edit]
            The label offset. Default is 0. Currently only available when -st/style is set
            to iconAndTextCentered.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - marginHeight : mh              (int)           [create,query,edit]
            The number of pixels above and below the control content. The default value is 1
            pixel.
        
        - marginWidth : mw               (int)           [create,query,edit]
            The number of pixels on either side of the control content. The default value is
            1 pixel.
        
        - menuItem : mi                  (unicode, unicode) [create,edit]
            Creates menu items for this button by passing in arguments for the menu item
            label and command for each item.  These should be passed as strings:
            labelcommandfor each use of this flag in the command.
        
        - menuItemPython : mip           (int)           [create,edit]
            This flag is used to specify that a menu item is in Python. The integer value is
            the index of the menuItem that is modified by this flag. This is 0 based, so it
            corresponds to the (index+1)th occurrence of the /-mi/-menuItemflag.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - noDefaultPopup : ndp           (bool)          [create]
            Disable the default popup menus.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - overlayLabelBackColor : olb    (float, float, float, float) [create,query,edit]
            The RGBA color of the shadow behind the label defined by imageOverlayLabel.
            Default is 50% transparent black: 0 0 0 .5
        
        - overlayLabelColor : olc        (float, float, float) [create,query,edit]
            The RGB color of the label defined by imageOverlayLabel. Default is a light
            grey: .8 .8 .8
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rotation : rot                 (float)         [create,query,edit]
            The rotation value of the image in radians.
        
        - scaleIcon : sic                (bool)          [create,edit]
            For textOnlyand iconOnlystyle, this flag has no effect. For other styles, if the
            flag is specified, the icon will be scaled to the size of the control.
        
        - selectionImage : si            (unicode)       [create,query,edit]
            Image displayed while the control is selected. Image size must be the same as
            the image specified with the -i/imageflag. This is a Windows only flag.
        
        - sourceType : stp               (unicode)       [create,query,edit]
            Sets the language type for the command script. Can only be used in conjunction
            with the c/command or dcc/doubleClickCommand flags. Valid values are mel(enabled
            by default), and python.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            The draw style of the control.  Valid styles are iconOnly, textOnly,
            iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note:
            iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set,
            the icon will be scaled to the size of the control.
        
        - useAlpha : ua                  (bool)          [create,query,edit]
            Is the image using alpha channel?
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this control feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.shelfButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'shelfButton'
    
    
    __melui__ = 'shelfButton'


class LayoutDialog(PyUI):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The layoutDialog command creates a modal dialog containing a formLayout with 100
        divisions. The formLayout can be populated with arbitrary UI elements through
        use of the '-ui/-uiScript' flag. NOTE:A layoutDialog is not a window and certain
        UI elements will not function properly within it. In particular menuBars and
        panels containing menuBars should not be used with the layoutDialog.
        
        Flags:
        - backgroundColor : bgc          (float, float, float) [create]
            The background color of the dialog. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
            (Windows only flag)
        
        - dismiss : dis                  (unicode)       [create]
            Dismiss the current layoutDialog. The specified string will be set as the result
            of the initial layoutDialog command.
        
        - parent : p                     (unicode)       [create]
            Specify the parent window for the dialog.  The dialog will be centered on this
            window and raise and lower with it's parent. By default, the dialog is not
            parented to a particular window and is simply centered on the screen.
        
        - title : t                      (unicode)       [create]
            The dialog title.
        
        - uiScript : ui                  (script)        [create]
            The specified MEL procedure name will be invoked to build the UI of the
            layoutDialog. This flag is required when creating a layoutDialog. The top-level
            control of a layoutDialog is a formLayout with 100 divisions. It can be accessed
            by calling 'setParent -q' at the beginning of the specified MEL procedure.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.layoutDialog`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'layoutDialog'
    
    
    __melui__ = 'layoutDialog'


class DeviceEditor(PyUI):
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def getTakePath(self, **kwargs):
        """
        The path used for writing/reading take data through the editor.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def setTakePath(self, val='True', **kwargs):
        """
        The path used for writing/reading take data through the editor.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This creates an editor for creating/modifying attachments to input devices.
        
        Dynamic library stub function 
        
        Flags:
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - takePath : tp                  (unicode)       [query,edit]
            The path used for writing/reading take data through the editor.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.deviceEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'deviceEditor'
    
    
    __melui__ = 'deviceEditor'


class CommandLine(PyUI):
    def command(self, val='True', **kwargs):
        """
        Command executed when the command line text changes.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def enterCommand(self, val='True', **kwargs):
        """
        Command executed when the keypad 'Enter' key is pressed.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getHoldFocus(self, **kwargs):
        """
        Sets whether the command line should hold focus after exectuing a command.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getInputAnnotation(self, **kwargs):
        """
        Annotate the input field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getNumberOfHistoryLines(self, **kwargs):
        """
        Sets the maximum number of commands saved to the command line history. Up to -nhl/numberOfHistoryLines previous commands will be available by pressing the up-arrow from within the input field. The default value is 50.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getOutputAnnotation(self, **kwargs):
        """
        Annotate the output field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getSourceType(self, **kwargs):
        """
        Sets the source type of this command line. Currently supports mel(enabled by default) and python.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setHoldFocus(self, val='True', **kwargs):
        """
        Sets whether the command line should hold focus after exectuing a command.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setInputAnnotation(self, val='True', **kwargs):
        """
        Annotate the input field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setNumberOfHistoryLines(self, val='True', **kwargs):
        """
        Sets the maximum number of commands saved to the command line history. Up to -nhl/numberOfHistoryLines previous commands will be available by pressing the up-arrow from within the input field. The default value is 50.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setOutputAnnotation(self, val='True', **kwargs):
        """
        Annotate the output field with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setSourceType(self, val='True', **kwargs):
        """
        Sets the source type of this command line. Currently supports mel(enabled by default) and python.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a single line for command input/output.The left half is for
        input, the right half for output.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - command : c                    (script)        [create,edit]
            Command executed when the command line text changes.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enterCommand : ec              (script)        [create,edit]
            Command executed when the keypad 'Enter' key is pressed.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - holdFocus : hf                 (bool)          [create,query,edit]
            Sets whether the command line should hold focus after exectuing a command.
        
        - inputAnnotation : ian          (unicode)       [create,query,edit]
            Annotate the input field with an extra string value.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfHistoryLines : nhl     (int)           [create,query,edit]
            Sets the maximum number of commands saved to the command line history. Up to
            -nhl/numberOfHistoryLines previous commands will be available by pressing the
            up-arrow from within the input field. The default value is 50.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - outputAnnotation : oan         (unicode)       [create,query,edit]
            Annotate the output field with an extra string value.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - sourceType : st                (unicode)       [create,query,edit]
            Sets the source type of this command line. Currently supports mel(enabled by
            default) and python.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.commandLine`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'commandLine'
    
    
    __melui__ = 'commandLine'


class MenuSet(PyUI):
    def getAllMenuSets(self, **kwargs):
        """
        Returns an array of the all the menu set object names in use.  Query returns string array.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getCurrentMenuSet(self, **kwargs):
        """
        The currently active menu set under which all operations affect (append, insert, remove, etc.).  Query returns string.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getExists(self, **kwargs):
        """
        Returns whether the specified menu set exists.  This query flag supports string arguments. ie. menuSet -q -exists animationMenuSet;       
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getHotBoxVisible(self, **kwargs):
        """
        Whether this menu set should be displayed in the hotbox as well as in the main menubar.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The label of the current menu set.  Query returns string.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getMenuArray(self, **kwargs):
        """
        An array of menu names (strings) in the current menu set.  Query returns string array.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getNumberOfMenuSets(self, **kwargs):
        """
        Number of menuSets in total.  Query returns int.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getNumberOfMenus(self, **kwargs):
        """
        The mumber of menus in the current menu set.  Query returns int.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def getPermanent(self, **kwargs):
        """
        Whether this menu set can be removed.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def setHotBoxVisible(self, val='True', **kwargs):
        """
        Whether this menu set should be displayed in the hotbox as well as in the main menubar.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    def setPermanent(self, val='True', **kwargs):
        """
        Whether this menu set can be removed.                  
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a menu set which is used to logically order menus for display in the main
        menu bar.  Such menu sets can be edited and reordered dynamically.
        
        Flags:
        - addMenu : am                   (unicode)       [create]
            Appends a menu onto the end of the current menu set.
        
        - allMenuSets : ams              (bool)          [query]
            Returns an array of the all the menu set object names in use.  Query returns
            string array.
        
        - currentMenuSet : cms           (unicode)       [create,query]
            The currently active menu set under which all operations affect (append, insert,
            remove, etc.).  Query returns string.
        
        - exists : ex                    (unicode)       [query]
            Returns whether the specified menu set exists.  This query flag supports string
            arguments. ie. menuSet -q -exists animationMenuSet;
        
        - hotBoxVisible : hbv            (bool)          [create,query,edit]
            Whether this menu set should be displayed in the hotbox as well as in the main
            menubar.
        
        - insertMenu : im                (unicode, int)  [create]
            Inserts a menu into a specified index in the current menu set.
        
        - label : l                      (unicode)       [create,query]
            The label of the current menu set.  Query returns string.
        
        - menuArray : ma                 (unicode)       [create,query]
            An array of menu names (strings) in the current menu set.  Query returns string
            array.
        
        - moveMenu : mm                  (unicode, int)  [create]
            Moves a specified menu from the current menu set to a new position.
        
        - moveMenuSet : mms              (unicode, int)  [create]
            Moves a specified menu set to another index.
        
        - numberOfMenuSets : nms         (bool)          [query]
            Number of menuSets in total.  Query returns int.
        
        - numberOfMenus : nm             (bool)          [query]
            The mumber of menus in the current menu set.  Query returns int.
        
        - permanent : p                  (bool)          [create,query,edit]
            Whether this menu set can be removed.
        
        - removeMenu : rm                (unicode)       [create]
            Removes a specified menu from the current menu set.
        
        - removeMenuSet : rms            (unicode)       [create]
            Removes the specified menu set object from the list of all menu sets.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.menuSet`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'menuSet'
    
    
    __melui__ = 'menuSet'


class BlendShapeEditor(PyUI):
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getTargetControlList(self, **kwargs):
        """
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getTargetList(self, **kwargs):
        """
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def getVerticalSliders(self, **kwargs):
        """
        Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def setVerticalSliders(self, val='True', **kwargs):
        """
        Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates an editor that derives from the base editor class that has
        controls for blendShape, control nodes.
        
        Flags:
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - targetControlList : tcl        (bool)          [query]
        
        - targetList : tl                (bool)          [query]
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - verticalSliders : vs           (bool)          [create,query,edit]
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.blendShapeEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'blendShapeEditor'
    
    
    __melui__ = 'blendShapeEditor'


class TextScrollList(PyUI):
    def append(self, val='True', **kwargs):
        """
        Add an item to the end of the list.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def appendPosition(self, val='True', **kwargs):
        """
        Append an item at the specified position. The position is a 1-based index.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def deleteKeyCommand(self, val='True', **kwargs):
        """
        Specify the command to be executed when the delete or backspace key is pressed.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def deselectAll(self, val='True', **kwargs):
        """
        Deselect all items.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def deselectIndexedItem(self, val='True', **kwargs):
        """
        Deselect the indexed item.  Indices are 1-based.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def deselectItem(self, val='True', **kwargs):
        """
        Deselect the item that contains the specified text.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def doubleClickCommand(self, val='True', **kwargs):
        """
        Specify the command to be executed when an item is double clicked.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def extend(self, appendList):
        """
        append a list of strings
        """
        pass
    def getAllItems(self, **kwargs):
        """
        All the items.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getAllowAutomaticSelection(self, **kwargs):
        """
        Specify automatic selection mode.  When automaticSelection is on each item that the mouse is over (during dragging once an item has been selected) will be selected.  Thus, if -sc/selectCommand someCommandis set, someCommandwill be called for each selected item. If -aas/allowAutomaticSelectionis off, then only the item selected when the mouse button is up will be the selected item, so -sc/selectCommand someCommandis only called once if it is set.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getAllowMultiSelection(self, **kwargs):
        """
        Specify multi or single selection mode.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the list items.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getNumberOfItems(self, **kwargs):
        """
        Number of items.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getNumberOfRows(self, **kwargs):
        """
        Number of visible rows.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getNumberOfSelectedItems(self, **kwargs):
        """
        Number of selected items.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getSelectIndexedItem(self, **kwargs):
        """
        Select the indexed item. Indices are 1-based.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getSelectItem(self, **kwargs):
        """
        Select the item that contains the specified text.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getSelectUniqueTagItem(self, **kwargs):
        """
        Allow item selections based on the unique tag. In query mode, it will return the unique tag of the selected items.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def lineFont(self, val='True', **kwargs):
        """
        Specify the font for a specific line of the list. The indices are 1-based. Valid font values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def removeAll(self, val='True', **kwargs):
        """
        Remove all items.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def removeIndexedItem(self, val='True', **kwargs):
        """
        Remove the indexed item. Indices are 1-based.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def removeIndexedItems(self, removeList):
        """
        remove a list of indices
        """
        pass
    def removeItem(self, val='True', **kwargs):
        """
        Remove the item with the specified text.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def selectAll(self):
        """
        select all items
        """
        pass
    def selectCommand(self, val='True', **kwargs):
        """
        Specify the command to be executed when an item is selected.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def selectIndexedItems(self, selectList):
        """
        select a list of indices
        """
        pass
    def setAllowAutomaticSelection(self, val='True', **kwargs):
        """
        Specify automatic selection mode.  When automaticSelection is on each item that the mouse is over (during dragging once an item has been selected) will be selected.  Thus, if -sc/selectCommand someCommandis set, someCommandwill be called for each selected item. If -aas/allowAutomaticSelectionis off, then only the item selected when the mouse button is up will be the selected item, so -sc/selectCommand someCommandis only called once if it is set.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setAllowMultiSelection(self, val='True', **kwargs):
        """
        Specify multi or single selection mode.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the list items.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setNumberOfRows(self, val='True', **kwargs):
        """
        Number of visible rows.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setSelectIndexedItem(self, val='True', **kwargs):
        """
        Select the indexed item. Indices are 1-based.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setSelectItem(self, val='True', **kwargs):
        """
        Select the item that contains the specified text.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setSelectUniqueTagItem(self, val='True', **kwargs):
        """
        Allow item selections based on the unique tag. In query mode, it will return the unique tag of the selected items.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def showIndexedItem(self, val='True', **kwargs):
        """
        Show the indexed item.  Scroll the list as necessary so that the indexed item is visible.  Indices are 1-based.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    def uniqueTag(self, val='True', **kwargs):
        """
        This flag can only be used in conjunction with the append or the appendPosition flag. The string specifies a unique tag for the appended item; the tag can then be used to query an item. This tag provides an alternate way to uniquely identify a list item using a string instead of by index. Tags are case insensitive.                  
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a text scrolling list. The list can be in
        single select mode where only one item at at time is selected, or in multi-
        select mode where many items may be selected. Note: The -dgc/dragCallback flag
        works only on Windows.
        
        Flags:
        - allItems : ai                  (bool)          [query]
            All the items.
        
        - allowAutomaticSelection : aas  (bool)          [create,query,edit]
            Specify automatic selection mode.  When automaticSelection is on each item that
            the mouse is over (during dragging once an item has been selected) will be
            selected.  Thus, if -sc/selectCommand someCommandis set, someCommandwill be
            called for each selected item. If -aas/allowAutomaticSelectionis off, then only
            the item selected when the mouse button is up will be the selected item, so
            -sc/selectCommand someCommandis only called once if it is set.
        
        - allowMultiSelection : ams      (bool)          [create,query,edit]
            Specify multi or single selection mode.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - append : a                     (unicode)       [create,edit]
            Add an item to the end of the list.
        
        - appendPosition : ap            (int, unicode)  [create,edit]
            Append an item at the specified position. The position is a 1-based index.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteKeyCommand : dkc         (script)        [create,edit]
            Specify the command to be executed when the delete or backspace key is pressed.
        
        - deselectAll : da               (bool)          [create,edit]
            Deselect all items.
        
        - deselectIndexedItem : dii      (int)           [create,edit]
            Deselect the indexed item.  Indices are 1-based.
        
        - deselectItem : di              (unicode)       [create,edit]
            Deselect the item that contains the specified text.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,edit]
            Specify the command to be executed when an item is double clicked.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the list items.  Valid values are boldLabelFont,
            smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont,
            obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - lineFont : lf                  (int, unicode)  [create,edit]
            Specify the font for a specific line of the list. The indices are 1-based. Valid
            font values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont,
            plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont,
            fixedWidthFontand smallFixedWidthFont.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfItems : ni             (bool)          [query]
            Number of items.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - numberOfRows : nr              (int)           [create,query,edit]
            Number of visible rows.
        
        - numberOfSelectedItems : nsi    (bool)          [query]
            Number of selected items.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - removeAll : ra                 (bool)          [create,edit]
            Remove all items.
        
        - removeIndexedItem : rii        (int)           [create,edit]
            Remove the indexed item. Indices are 1-based.
        
        - removeItem : ri                (unicode)       [create,edit]
            Remove the item with the specified text.
        
        - selectCommand : sc             (script)        [create,edit]
            Specify the command to be executed when an item is selected.
        
        - selectIndexedItem : sii        (int)           [create,query,edit]
            Select the indexed item. Indices are 1-based.
        
        - selectItem : si                (unicode)       [create,query,edit]
            Select the item that contains the specified text.
        
        - selectUniqueTagItem : sut      (unicode)       [create,query,edit]
            Allow item selections based on the unique tag. In query mode, it will return the
            unique tag of the selected items.
        
        - showIndexedItem : shi          (int)           [create,edit]
            Show the indexed item.  Scroll the list as necessary so that the indexed item is
            visible.  Indices are 1-based.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - uniqueTag : utg                (unicode)       [create,edit]
            This flag can only be used in conjunction with the append or the appendPosition
            flag. The string specifies a unique tag for the appended item; the tag can then
            be used to query an item. This tag provides an alternate way to uniquely
            identify a list item using a string instead of by index. Tags are case
            insensitive.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.textScrollList`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'textScrollList'
    
    
    __melui__ = 'textScrollList'


class IconTextRadioCollection(PyUI):
    def disableCommands(self, val='True', **kwargs):
        """
        Allows a particular iconTextRadioButton in the collection to be selected without invoking the commands attached to the -cc/changeCommand, -onc/onCommand, or -ofc/offCommand flags. This flag is only meaningful when used in conjuction with the -edit and -select flags.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioCollection`
        """
        pass
    def getCollectionItemArray(self, **kwargs):
        """
        Returns a string list giving the long names of all the items in this collection.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioCollection`
        """
        pass
    def getGl(self, **kwargs):
        """
        Set the collection to have no parent layout.  If the collection has a parent layout then it will be deleted with that layout, otherwise if it is specified to be global it must be explicitly deleted.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioCollection`
        """
        pass
    def getNumberOfCollectionItems(self, **kwargs):
        """
        Returns the number of items that are in this collection.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioCollection`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Select the specified collection item.  If queried will return the name of the currently selected collection item.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioCollection`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Select the specified collection item.  If queried will return the name of the currently selected collection item.                  
        
        
        Derived from mel command `maya.cmds.iconTextRadioCollection`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a cluster for iconTextRadioButtons.  Clusters will be
        parented to the current default layout if no parent is specified with the
        -p/parent flag. As children of the layout they will be deleted when the layout
        is deleted. Clusters may also span more than one window if the -g/global flag is
        used. In this case the cluster has no parent so must be explicitly deleted with
        the 'deleteUI' command.
        
        Flags:
        - collectionItemArray : cia      (bool)          [query]
            Returns a string list giving the long names of all the items in this collection.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disableCommands : dcm          (bool)          [edit]
            Allows a particular iconTextRadioButton in the collection to be selected without
            invoking the commands attached to the -cc/changeCommand, -onc/onCommand, or
            -ofc/offCommand flags. This flag is only meaningful when used in conjuction with
            the -edit and -select flags.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - gl : gl                        (bool)          [create,query]
            Set the collection to have no parent layout.  If the collection has a parent
            layout then it will be deleted with that layout, otherwise if it is specified to
            be global it must be explicitly deleted.
        
        - numberOfCollectionItems : nci  (bool)          [query]
            Returns the number of items that are in this collection.
        
        - parent : p                     (unicode)       [create]
            Set the specified layout to be the parent layout of the cluster.
        
        - select : sl                    (unicode)       [create,query,edit]
            Select the specified collection item.  If queried will return the name of the
            currently selected collection item.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.iconTextRadioCollection`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'iconTextRadioCollection'
    
    
    __melui__ = 'iconTextRadioCollection'


class ChannelBox(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def execute(self, val='True', **kwargs):
        """
        Immediately executes the command string once for every cell (or every selected cell, if the boolean argument is TRUE) in the channel box, for every matching selected object (ie, for every object would be affected if you changed a cell value.)  Before the command is executed, #Ais substituted with the name of the attribute, and #Nwith the name of the node, and #Pwith the full path name of the node.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getAttrBgColor(self, **kwargs):
        """
        Controls the background text color of specific attribute names. As with the foreground option, this text coloring also depends on the node name choice for the nodeRegex flag. Arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. If attrRegex is unspecified then it will assume a value of \*for a regular expression. The same idea simultaneously applies to the flag nodeRegex. Note: nodes that are renamed will have their node name coloring be affected in the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getAttrColor(self, **kwargs):
        """
        Controls the foreground text color of specific attribute names. This text coloring also depends on the node name choice for the nodeRegex flag. Arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. If attrRegex is unspecified then it will assume a value of \*for a regular expression. The same idea simultaneously applies to the flag nodeRegex. Note: nodes that are renamed will have their node name coloring be affected in the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getAttrFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be placed on the channel box. This filters the attributes displayed. A filter of 0can be used to reset the filter.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getAttrRegex(self, **kwargs):
        """
        Specifies a valid regular expression to specify which attribute names should be selected for foreground text coloring. If attrRegex is unspecified then it will assume a value of \*for a regular expression. The same idea simultaneously applies to the flag nodeRegex. The attrColor flag is required to be specified. Note: this regular expression will be treated as though it were case-insensitve                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getAttributeEditorMode(self, **kwargs):
        """
        Modifies what appears in the channel box for use in the attribute editor. Default is false. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getContainerAtTop(self, **kwargs):
        """
        This flag can be used to specify whether or not the container is drawn at the top of the channel box when a node in the container is selected.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getEnableLabelSelection(self, **kwargs):
        """
        Enables the selection of attributes in the channelBox when used in conjunction with -attributeEditorMode. Default is false.  Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getFieldWidth(self, **kwargs):
        """
        An optional flag which is used to modify the width assigned to fields appearing in the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getFixedAttrList(self, **kwargs):
        """
        Forces the channel box to only display attributes with the specified names, in the order they are specified.  If an empty list is specified, then the channel box will revert to its default behaviour of listing all keyable attributes.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getHistoryObjectList(self, **kwargs):
        """
        Returns a list of strings, the names of every INPUT node associated with an object on the main object list that is of the same type as the node displayed in the INPUT section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getHyperbolic(self, **kwargs):
        """
        Determines whether or not the distance that the mouse has been dragged should be interpreted as a linear or hyperbolic function.  The default is set to hyperbolic being false.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getInputs(self, **kwargs):
        """
        Returns the items shown under the 'INPUTS' heading in the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getLabelWidth(self, **kwargs):
        """
        An optional flag which is used to modify the width assigned to labels appearing in the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getLongNames(self, **kwargs):
        """
        Controls whether long or short attribute names will be used in the interface.  Note that this flag is ignored if the -niceNames flag is set.  Default is short names. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object which the editor will use as its source of content.  The channel box will only display the (last) item contained in the selectionConnection object. If a NULL string () is specified, then the channel box will revert to its default behaviour of working on the active list.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getMainObjectList(self, **kwargs):
        """
        Returns a list of strings, the names of every object on the active list that is the same type as the object displayed in the top (main) section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getMaxHeight(self, **kwargs):
        """
        An optional flag which is used to limit the height of the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getMaxWidth(self, **kwargs):
        """
        An optional flag which is used to limit the width of the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getNiceNames(self, **kwargs):
        """
        Controls whether the attribute names will be displayed in a more user-friendly, readable way.  When this is on, the longNames flag is ignored.  When this is off, attribute names will be displayed either long or short, according to the longNames flag. Default is on. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getNodeRegex(self, **kwargs):
        """
        Specifies a valid regular expression to specify which node names should (potentially) have their attributes selected for foreground text coloring. If nodeRegex is unspecified then it will assume a value of \*' for a regular expression. The same idea simultaneously applies to the flag attrRegex. The attrColor flag is required to be specified. Note: this regular expression will be treated as though it were case-insensitve Note: nodes in namespaces have regular expressions applied as though those nodes weren't in namespaces                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getOutputObjectList(self, **kwargs):
        """
        Returns a list of strings, the names of every OUTPUT node associated an object on the main object list that is of the same type as the node displayed in the OUTPUT section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getOutputs(self, **kwargs):
        """
        Returns the items shown under the 'OUTPUTS' heading in the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getPrecision(self, **kwargs):
        """
        Controls the number of digits to the right of the decimal point that will be displayed for float-valued channels. Default is 3.  Queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getSelectedHistoryAttributes(self, **kwargs):
        """
        Returns a list of strings, the names of all the selected attributes in the INPUT section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getSelectedMainAttributes(self, **kwargs):
        """
        Returns a list of strings, the names of all the selected attributes in the top section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getSelectedOutputAttributes(self, **kwargs):
        """
        Returns a list of strings, the names of all the selected attributes in the OUTPUT section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getSelectedShapeAttributes(self, **kwargs):
        """
        Returns a list of strings, the names of all the selected attributes in the middle (shape) section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getShapeObjectList(self, **kwargs):
        """
        Returns a list of strings, the names of every shape associated with an object on the main object list that is of the same type as the object displayed in the middle (shape) section of the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getShapes(self, **kwargs):
        """
        Returns the items shown under the 'SHAPES' heading in the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getShowNamespace(self, **kwargs):
        """
        Controls whether or not the namespace of an object is displayed if the object is not in the root namespace.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getShowTransforms(self, **kwargs):
        """
        Controls whether this control will display transform attributes only, or all other attributes. False by default. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getSpeed(self, **kwargs):
        """
        Controls the speed at which the attributes are changed based on the distance the mouse has been dragged.  Common settings for slow/medium/fast are 0.1/1.0/10.0 respectively.  The default is 1.0.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getUseManips(self, **kwargs):
        """
        When you click on a field or label in the channel box, the tool switches to a manipulator that can change that value if you drag in the 3d view.  This flag controls the kind of manips.  Allowed values are none(self-explanatory), invisible(you won't see anything, but dragging in the window will adjust any of the selected attributes), and standard(the same as invisible, except for scale, rotate, and translate, which will be represented by their usual manips.)                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def select(self, val='True', **kwargs):
        """
        Allows programmatic selection of items (nodes or plugs) in the channel box. Selection is equivalent to clicking the item with the mouse; therefore only items currently shown in the channel box can be selected this way.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setAttrBgColor(self, val='True', **kwargs):
        """
        Controls the background text color of specific attribute names. As with the foreground option, this text coloring also depends on the node name choice for the nodeRegex flag. Arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. If attrRegex is unspecified then it will assume a value of \*for a regular expression. The same idea simultaneously applies to the flag nodeRegex. Note: nodes that are renamed will have their node name coloring be affected in the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setAttrColor(self, val='True', **kwargs):
        """
        Controls the foreground text color of specific attribute names. This text coloring also depends on the node name choice for the nodeRegex flag. Arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. If attrRegex is unspecified then it will assume a value of \*for a regular expression. The same idea simultaneously applies to the flag nodeRegex. Note: nodes that are renamed will have their node name coloring be affected in the channel box.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setAttrFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be placed on the channel box. This filters the attributes displayed. A filter of 0can be used to reset the filter.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setAttrRegex(self, val='True', **kwargs):
        """
        Specifies a valid regular expression to specify which attribute names should be selected for foreground text coloring. If attrRegex is unspecified then it will assume a value of \*for a regular expression. The same idea simultaneously applies to the flag nodeRegex. The attrColor flag is required to be specified. Note: this regular expression will be treated as though it were case-insensitve                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setAttributeEditorMode(self, val='True', **kwargs):
        """
        Modifies what appears in the channel box for use in the attribute editor. Default is false. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setContainerAtTop(self, val='True', **kwargs):
        """
        This flag can be used to specify whether or not the container is drawn at the top of the channel box when a node in the container is selected.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setEnableLabelSelection(self, val='True', **kwargs):
        """
        Enables the selection of attributes in the channelBox when used in conjunction with -attributeEditorMode. Default is false.  Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setFieldWidth(self, val='True', **kwargs):
        """
        An optional flag which is used to modify the width assigned to fields appearing in the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setFixedAttrList(self, val='True', **kwargs):
        """
        Forces the channel box to only display attributes with the specified names, in the order they are specified.  If an empty list is specified, then the channel box will revert to its default behaviour of listing all keyable attributes.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setHyperbolic(self, val='True', **kwargs):
        """
        Determines whether or not the distance that the mouse has been dragged should be interpreted as a linear or hyperbolic function.  The default is set to hyperbolic being false.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setLabelWidth(self, val='True', **kwargs):
        """
        An optional flag which is used to modify the width assigned to labels appearing in the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setLongNames(self, val='True', **kwargs):
        """
        Controls whether long or short attribute names will be used in the interface.  Note that this flag is ignored if the -niceNames flag is set.  Default is short names. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object which the editor will use as its source of content.  The channel box will only display the (last) item contained in the selectionConnection object. If a NULL string () is specified, then the channel box will revert to its default behaviour of working on the active list.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setMaxHeight(self, val='True', **kwargs):
        """
        An optional flag which is used to limit the height of the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setMaxWidth(self, val='True', **kwargs):
        """
        An optional flag which is used to limit the width of the channelBox.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setNiceNames(self, val='True', **kwargs):
        """
        Controls whether the attribute names will be displayed in a more user-friendly, readable way.  When this is on, the longNames flag is ignored.  When this is off, attribute names will be displayed either long or short, according to the longNames flag. Default is on. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setNodeRegex(self, val='True', **kwargs):
        """
        Specifies a valid regular expression to specify which node names should (potentially) have their attributes selected for foreground text coloring. If nodeRegex is unspecified then it will assume a value of \*' for a regular expression. The same idea simultaneously applies to the flag attrRegex. The attrColor flag is required to be specified. Note: this regular expression will be treated as though it were case-insensitve Note: nodes in namespaces have regular expressions applied as though those nodes weren't in namespaces                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setPrecision(self, val='True', **kwargs):
        """
        Controls the number of digits to the right of the decimal point that will be displayed for float-valued channels. Default is 3.  Queried, returns an int.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setShowNamespace(self, val='True', **kwargs):
        """
        Controls whether or not the namespace of an object is displayed if the object is not in the root namespace.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setShowTransforms(self, val='True', **kwargs):
        """
        Controls whether this control will display transform attributes only, or all other attributes. False by default. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setSpeed(self, val='True', **kwargs):
        """
        Controls the speed at which the attributes are changed based on the distance the mouse has been dragged.  Common settings for slow/medium/fast are 0.1/1.0/10.0 respectively.  The default is 1.0.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setUseManips(self, val='True', **kwargs):
        """
        When you click on a field or label in the channel box, the tool switches to a manipulator that can change that value if you drag in the 3d view.  This flag controls the kind of manips.  Allowed values are none(self-explanatory), invisible(you won't see anything, but dragging in the window will adjust any of the selected attributes), and standard(the same as invisible, except for scale, rotate, and translate, which will be represented by their usual manips.)                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def takeFocus(self, val='True', **kwargs):
        """
        causes the channel box to take over the keyboard focus, if it can.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    def update(self, val='True', **kwargs):
        """
        This flag can be used to force an update of the channel box display, for example after changing a display preference.                  
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a channel box, which is sensitive to the active list.  It
        displays certain attributes (channels) of the last node on the active list, and
        provides a two-way connection to keep the widget up to date. Note: when setting
        the color of attribute names, that color is only valid for its current Maya
        session; each subsequent session will display the default color for the
        attribute name(s) listed in the Channel Box. Any subsequent attributes that are
        added to the Channel Box will be affected by prior regular expressions in their
        current Maya session.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attrBgColor : bc               (float, float, float) [create,query,edit]
            Controls the background text color of specific attribute names. As with the
            foreground option, this text coloring also depends on the node name choice for
            the nodeRegex flag. Arguments correspond to the red, green, and blue color
            components. Each component ranges in value from 0.0 to 1.0. If attrRegex is
            unspecified then it will assume a value of \*for a regular expression. The same
            idea simultaneously applies to the flag nodeRegex. Note: nodes that are renamed
            will have their node name coloring be affected in the channel box.
        
        - attrColor : ac                 (float, float, float) [create,query,edit]
            Controls the foreground text color of specific attribute names. This text
            coloring also depends on the node name choice for the nodeRegex flag. Arguments
            correspond to the red, green, and blue color components. Each component ranges
            in value from 0.0 to 1.0. If attrRegex is unspecified then it will assume a
            value of \*for a regular expression. The same idea simultaneously applies to the
            flag nodeRegex. Note: nodes that are renamed will have their node name coloring
            be affected in the channel box.
        
        - attrFilter : af                (unicode)       [query,edit]
            Specifies the name of an itemFilter object to be placed on the channel box. This
            filters the attributes displayed. A filter of 0can be used to reset the filter.
        
        - attrRegex : ar                 (unicode)       [create,query,edit]
            Specifies a valid regular expression to specify which attribute names should be
            selected for foreground text coloring. If attrRegex is unspecified then it will
            assume a value of \*for a regular expression. The same idea simultaneously
            applies to the flag nodeRegex. The attrColor flag is required to be specified.
            Note: this regular expression will be treated as though it were case-insensitve
        
        - attributeEditorMode : aem      (bool)          [query,edit]
            Modifies what appears in the channel box for use in the attribute editor.
            Default is false. Queried, returns a boolean.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - containerAtTop : cat           (bool)          [query,edit]
            This flag can be used to specify whether or not the container is drawn at the
            top of the channel box when a node in the container is selected.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enableLabelSelection : els     (bool)          [query,edit]
            Enables the selection of attributes in the channelBox when used in conjunction
            with -attributeEditorMode. Default is false.  Queried, returns a boolean.
        
        - execute : exe                  (unicode, bool) [edit]
            Immediately executes the command string once for every cell (or every selected
            cell, if the boolean argument is TRUE) in the channel box, for every matching
            selected object (ie, for every object would be affected if you changed a cell
            value.)  Before the command is executed, #Ais substituted with the name of the
            attribute, and #Nwith the name of the node, and #Pwith the full path name of the
            node.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fieldWidth : fw                (int)           [query,edit]
            An optional flag which is used to modify the width assigned to fields appearing
            in the channelBox.
        
        - fixedAttrList : fal            (unicode)       [create,query,edit]
            Forces the channel box to only display attributes with the specified names, in
            the order they are specified.  If an empty list is specified, then the channel
            box will revert to its default behaviour of listing all keyable attributes.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - historyObjectList : hol        (bool)          [query]
            Returns a list of strings, the names of every INPUT node associated with an
            object on the main object list that is of the same type as the node displayed in
            the INPUT section of the channel box.
        
        - hyperbolic : hyp               (bool)          [create,query,edit]
            Determines whether or not the distance that the mouse has been dragged should be
            interpreted as a linear or hyperbolic function.  The default is set to
            hyperbolic being false.
        
        - inputs : inputs                (bool)          [query]
            Returns the items shown under the 'INPUTS' heading in the channel box.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - labelWidth : lw                (int)           [query,edit]
            An optional flag which is used to modify the width assigned to labels appearing
            in the channelBox.
        
        - longNames : ln                 (bool)          [query,edit]
            Controls whether long or short attribute names will be used in the interface.
            Note that this flag is ignored if the -niceNames flag is set.  Default is short
            names. Queried, returns a boolean.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object which the editor will use as
            its source of content.  The channel box will only display the (last) item
            contained in the selectionConnection object. If a NULL string () is specified,
            then the channel box will revert to its default behaviour of working on the
            active list.
        
        - mainObjectList : mol           (bool)          [query]
            Returns a list of strings, the names of every object on the active list that is
            the same type as the object displayed in the top (main) section of the channel
            box.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxHeight : mh                 (int)           [query,edit]
            An optional flag which is used to limit the height of the channelBox.
        
        - maxWidth : mw                  (int)           [query,edit]
            An optional flag which is used to limit the width of the channelBox.
        
        - niceNames : nn                 (bool)          [query,edit]
            Controls whether the attribute names will be displayed in a more user-friendly,
            readable way.  When this is on, the longNames flag is ignored.  When this is
            off, attribute names will be displayed either long or short, according to the
            longNames flag. Default is on. Queried, returns a boolean.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - nodeRegex : nr                 (unicode)       [create,query,edit]
            Specifies a valid regular expression to specify which node names should
            (potentially) have their attributes selected for foreground text coloring. If
            nodeRegex is unspecified then it will assume a value of \*' for a regular
            expression. The same idea simultaneously applies to the flag attrRegex. The
            attrColor flag is required to be specified. Note: this regular expression will
            be treated as though it were case-insensitve Note: nodes in namespaces have
            regular expressions applied as though those nodes weren't in namespaces
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - outputObjectList : ool         (bool)          [query]
            Returns a list of strings, the names of every OUTPUT node associated an object
            on the main object list that is of the same type as the node displayed in the
            OUTPUT section of the channel box.
        
        - outputs : out                  (bool)          [query]
            Returns the items shown under the 'OUTPUTS' heading in the channel box.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [query,edit]
            Controls the number of digits to the right of the decimal point that will be
            displayed for float-valued channels. Default is 3.  Queried, returns an int.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - select : s                     (unicode)       [edit]
            Allows programmatic selection of items (nodes or plugs) in the channel box.
            Selection is equivalent to clicking the item with the mouse; therefore only
            items currently shown in the channel box can be selected this way.
        
        - selectedHistoryAttributes : sha (bool)          [query]
            Returns a list of strings, the names of all the selected attributes in the INPUT
            section of the channel box.
        
        - selectedMainAttributes : sma   (bool)          [query]
            Returns a list of strings, the names of all the selected attributes in the top
            section of the channel box.
        
        - selectedOutputAttributes : soa (bool)          [query]
            Returns a list of strings, the names of all the selected attributes in the
            OUTPUT section of the channel box.
        
        - selectedShapeAttributes : ssa  (bool)          [query]
            Returns a list of strings, the names of all the selected attributes in the
            middle (shape) section of the channel box.
        
        - shapeObjectList : sol          (bool)          [query]
            Returns a list of strings, the names of every shape associated with an object on
            the main object list that is of the same type as the object displayed in the
            middle (shape) section of the channel box.
        
        - shapes : shp                   (bool)          [query]
            Returns the items shown under the 'SHAPES' heading in the channel box.
        
        - showNamespace : sn             (bool)          [create,query,edit]
            Controls whether or not the namespace of an object is displayed if the object is
            not in the root namespace.
        
        - showTransforms : st            (bool)          [query,edit]
            Controls whether this control will display transform attributes only, or all
            other attributes. False by default. Queried, returns a boolean.
        
        - speed : spd                    (float)         [create,query,edit]
            Controls the speed at which the attributes are changed based on the distance the
            mouse has been dragged.  Common settings for slow/medium/fast are 0.1/1.0/10.0
            respectively.  The default is 1.0.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - takeFocus : tf                 (bool)          [edit]
            causes the channel box to take over the keyboard focus, if it can.
        
        - update : u                     (bool)          [edit]
            This flag can be used to force an update of the channel box display, for example
            after changing a display preference.
        
        - useManips : mnp                (unicode)       [create,query,edit]
            When you click on a field or label in the channel box, the tool switches to a
            manipulator that can change that value if you drag in the 3d view.  This flag
            controls the kind of manips.  Allowed values are none(self-explanatory),
            invisible(you won't see anything, but dragging in the window will adjust any of
            the selected attributes), and standard(the same as invisible, except for scale,
            rotate, and translate, which will be represented by their usual manips.)
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.channelBox`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'channelBox'
    
    
    __melui__ = 'channelBox'


class Panel(PyUI):
    """
    pymel panel class
    """
    
    
    
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command allows editing or querying properties of any panels. Not all of the
        common properites of panels can be used with this command. Flags such as
        -tearOff and -replacePanel require that you use the explicit panel command. The
        command 'getPanel -typeOf panelName' will return the explicit type of a panel.
        In query mode, return type is based on queried flag.
        
        Flags:
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.panel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'panel'
    
    
    __melui__ = 'panel'


class ShellField(PyUI):
    __melui__ = 'shellField'


class KeyframeOutliner(PyUI):
    def animCurve(self, val='True', **kwargs):
        """
        Name of the animation curve for which to display keyframes.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getDisplay(self, **kwargs):
        """
        narrow | wide What columns to display.  When narrow, time and value will be displayed, when widetangent information will be displayed as well                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setDisplay(self, val='True', **kwargs):
        """
        narrow | wide What columns to display.  When narrow, time and value will be displayed, when widetangent information will be displayed as well                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a keyframe outliner control.
        
        Flags:
        - animCurve : ac                 (unicode)       [edit]
            Name of the animation curve for which to display keyframes.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - display : dsp                  (unicode)       [query,edit]
            narrow | wide What columns to display.  When narrow, time and value will be
            displayed, when widetangent information will be displayed as well
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.keyframeOutliner`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'keyframeOutliner'
    
    
    __melui__ = 'keyframeOutliner'


class FontDialog(PyUI):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Displays a dialog of available fonts for the user to select from. The name of
        the selected font is returned, or an empty string if no font was selected. When
        the FontListflag is used, no dialog is displayed. Instead the command returns an
        array of the available fonts.
        
        Flags:
        - FontList : fl                  (bool)          [create]
            Returns an array of all available font names. No dialog is displayed.
        
        - scalable : sc                  (bool)          [create]
            Limits the fonts returned or displayed to just those that are scalable.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.fontDialog`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'fontDialog'
    
    
    __melui__ = 'fontDialog'


class ModelEditor(PyUI):
    def activeCustomEnvironment(self, val='True', **kwargs):
        """
        Specifies a path to an image file to be used as environment map. It is only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def addObjects(self, val='True', **kwargs):
        """
        This flag causes the objects contained within the selection connection to be added to the list of objects visible in the view (if viewSelected is true).                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def addSelected(self, val='True', **kwargs):
        """
        This flag causes the currently active objects to be added to the list of objects visible in the view (if viewSelected is true).                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def cameraName(self, val='True', **kwargs):
        """
        Set the name of the panel's camera transform and shape. The shape name is computed by appending the string Shapeto the transform name. This flag may not be queried.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveComponentsXray(self, **kwargs):
        """
        Turns on or off Xray mode for active components.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveCustomGeometry(self, **kwargs):
        """
        Specifies an identifier for custom geometry to override the geometry to display. It is only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveCustomLighSet(self, **kwargs):
        """
        Specifies an identifier for the light set to use with a scene render filter. It is only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveCustomOverrideGeometry(self, **kwargs):
        """
        Specifies an identifier for an override on the custom geometry for a scene render filter.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveCustomRenderer(self, **kwargs):
        """
        Specifies an identifier for custom renderer to use when a valid scene render filter is also specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveOnly(self, **kwargs):
        """
        Sets whether only active objects should appear shaded in shaded display.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveShadingGraph(self, **kwargs):
        """
        Specifies the shading graph to use to override material display. Only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getActiveView(self, **kwargs):
        """
        Sets this model editor to be the active view.  Returns true if successful.  On query this flag will return whether the view is the active view.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getAllObjects(self, **kwargs):
        """
        Turn on/off the display of all objects for the view of the model editor. This excludes NURBS, CVs, hulls, grids and manipulators.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getBackfaceCulling(self, **kwargs):
        """
        Turns on or off backface culling for the whole view.  This setting overrides the culling settings of individual objects.  All objects draw in the view will be backface culled.  When backface culling is turned on, surfaces becomes invisible in areas where the normal is pointing away from the camera.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getBufferMode(self, **kwargs):
        """
        Deprecated: this is not supported in Viewport 2.0.  Sets the graphic buffer mode.  Possible values are singleor double.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getBumpResolution(self, **kwargs):
        """
        Set the resolution for bakedbump map textures when using the hardware renderer. The default value is 512, 512 respectively.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCamera(self, **kwargs):
        """
        Change or query the name of the camera in model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCameraSet(self, **kwargs):
        """
        Name of the camera set                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCameraSetup(self, **kwargs):
        """
        Based on the model editor name passed in will returns a string list containing camera setups. A camera setup can contain one or more cameras which are associated with each other. Camera setups are defined as pairs of consecutive strings in the list. Each pair is comprised of: a string which identifies an active camera, and a string which defines a script to set up a given active camera. As many pairs of strings can be returned as the number of active cameras. If nothing is returned then it is assumed that no set up is required to activate a given camera.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCameras(self, **kwargs):
        """
        Turn on/off the display of cameras for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCapture(self, **kwargs):
        """
        Perform an one-time capture of the viewport to the named image file on disk.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCaptureSequenceNumber(self, **kwargs):
        """
        When a number greater or equal to 0 is specified each subsequent refresh will save an image file to disk if the capture flag has been enabled.  The naming of the file is:  {root name}.#.{extension}  if the name {root name}.{extension} is used for the capture flag argument.  The value of # starts at the number specified to for this argument and increments for each subsequent refresh.  Sequence capture can be disabled by specifying a number less than 0 or an empty file name for the capture flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getClipGhosts(self, **kwargs):
        """
        Define whether the clip ghosts should be added or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCmEnabled(self, **kwargs):
        """
        Turn on or off applying color management in the editor.  If set, the color management configuration set in the current editor is used.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getColorMap(self, **kwargs):
        """
        Queries the color map style for the model panel. Possible values are colorIndexand rgb.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getColorResolution(self, **kwargs):
        """
        Set the resolution for bakedcolor textures when using the hardware renderer. The default value is 256, 256 respectively.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getControlVertices(self, **kwargs):
        """
        Turn on/off the display of NURBS CVs for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getCullingOverride(self, **kwargs):
        """
        Set whether to override the culling attributes on objects when using the hardware renderer. The options are: none: Use the culling object attributes per object.doubleSided: Force all objects to be double sided.singleSided: Force all objects to be single sided.The default value is none.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDefault(self, **kwargs):
        """
        Causes this command to modify the default value of this setting. Newly created model editors will inherit the values.  This flag may be used with the -interactive to set default interactive settings.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDeformers(self, **kwargs):
        """
        Turn on/off the display of deformer objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDimensions(self, **kwargs):
        """
        Turn on/off the display of dimension objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDisplayAppearance(self, **kwargs):
        """
        Sets the display appearance of the model panel.  Possible values are wireframe, points, boundingBox, smoothShaded, flatShaded.  This flag may be used with the -interactive and -default flags.  Note that only wireframe, points, and boundingBoxare valid for the interactive mode.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDisplayLights(self, **kwargs):
        """
        Sets the lighting for shaded mode.  Possible values are selected, active, all, default, none.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDisplayTextures(self, **kwargs):
        """
        Turns on or off display of textures in shaded mode                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDynamicConstraints(self, **kwargs):
        """
        Turn on/off the display of dynamicConstraints for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getDynamics(self, **kwargs):
        """
        Turn on/off the display of dynamics objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getEditorChanged(self, **kwargs):
        """
        An optional script callback which is called when the editors options have changed.  This is useful in a situation where a scripted panel contains a modelEditor and wants to be notified when the contained editor changes its options.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getExposure(self, **kwargs):
        """
        The exposure value used by the color management of the current editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFilteredObjectList(self, **kwargs):
        """
        For model editors with filtering on (either using an object filter, or isolate select), this flag returns a string list of the objects which are displayed in this editor. Note that this list does not take into account visibility (based on camera frustum or flags), it purely captures the objects which are considered when rendering the view.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFluids(self, **kwargs):
        """
        Turn on/off the display of fluids for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFogColor(self, **kwargs):
        """
        The color used for hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFogDensity(self, **kwargs):
        """
        Determines the density of hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFogEnd(self, **kwargs):
        """
        The end location of hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFogMode(self, **kwargs):
        """
        This determines the drop-off mode for fog. The possibilities are: linear: linear drop-offexponent: exponential drop-offexponent2: squared exponential drop-off
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFogSource(self, **kwargs):
        """
        Set the type of fog algorithm to use. If the argument is fragment(default) then fog is computed per pixel. If the argument is coordinatethen if the geometry has specified vertex fog coordinates, and the OpenGL extension for vertex fog is supported by the graphics system, then fog is computed per vertex.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFogStart(self, **kwargs):
        """
        The start location of hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFogging(self, **kwargs):
        """
        Set whether hardware fogging is enabled or not.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getFollicles(self, **kwargs):
        """
        Turn on/off the display of follicles for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getGamma(self, **kwargs):
        """
        The gamma value used by the color management of the current editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getGreasePencils(self, **kwargs):
        """
        Define whether the grease pencil marks should be added or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getGrid(self, **kwargs):
        """
        Turn on/off the display of the grid for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getHairSystems(self, **kwargs):
        """
        Turn on/off the display of hairSystems for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getHandles(self, **kwargs):
        """
        Turn on/off the display of select handles for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getHeadsUpDisplay(self, **kwargs):
        """
        Sets whether the model panel will draw any enabled heads up display     elements in this window (if true).  Currently this requires the HUD elements to be globally enabled.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Return the height of the associated viewport in pixels                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getHulls(self, **kwargs):
        """
        Turn on/off the display of NURBS hulls for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getIgnorePanZoom(self, **kwargs):
        """
        Sets whether the model panel will ignore the 2D pan/zoom value to give an overview of the scene.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getIkHandles(self, **kwargs):
        """
        Turn on/off the display of ik handles and end effectors for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getImagePlane(self, **kwargs):
        """
        Turn on/off the display of image plane for the view                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getInteractive(self, **kwargs):
        """
        Causes this command to modify the interactive refresh settings of the view.  In this way it is possible to change the behavior of the model editor during playback for improved performance.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getInteractiveBackFaceCull(self, **kwargs):
        """
        Define whether interactive backface culling should be on or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getInteractiveDisableShadows(self, **kwargs):
        """
        Define whether interactive shadows should be disabled or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getIsFiltered(self, **kwargs):
        """
        Returns true for model editors with filtering applied to their view of the scene. This could either be an explicit object filter, or a display option such as isolate select which filters the objects that are displayed.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getJointXray(self, **kwargs):
        """
        Turns on or off Xray mode for joints.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getJoints(self, **kwargs):
        """
        Turn on/off the display of joints for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getLights(self, **kwargs):
        """
        Turn on/off the display of lights for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getLineWidth(self, **kwargs):
        """
        Set width of lines for display                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getLocators(self, **kwargs):
        """
        Turn on/off the display of locator objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getLowQualityLighting(self, **kwargs):
        """
        Set whether to use low quality lightingwhen using the hardware renderer. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getManipulators(self, **kwargs):
        """
        Turn on/off the display of manipulator objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getMaxConstantTransparency(self, **kwargs):
        """
        Sets the maximum constant transparency.  Setting this value remaps constant transparency values from the range [0.0, 1.0] to the range [0.0, maxConstantTransparency]. All transparency values are shifted linearly to the new range, so a fully transparency object (transparency 1.0) would appear with a transparency of maxConstantTransparency in the viewport, allowing highly transparent objects to be made visible.  This flag only affects constant (non-textured) transparent objects.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getMaximumNumHardwareLights(self, **kwargs):
        """
        Define whether the hardware light maximum should be respected or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getMotionTrails(self, **kwargs):
        """
        Turn on/off the Motion Trail display in the Viewport.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getNCloths(self, **kwargs):
        """
        Turn on/off the display of nCloths for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getNParticles(self, **kwargs):
        """
        Turn on/off the display of nParticles for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getNRigids(self, **kwargs):
        """
        Turn on/off the display of nRigids for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getNurbsCurves(self, **kwargs):
        """
        Turn on/off the display of nurbs curves for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getNurbsSurfaces(self, **kwargs):
        """
        Turn on/off the display of nurbs surfaces for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getObjectFilter(self, **kwargs):
        """
        Set or query the current object filter name. An object filter is required to have already been registered.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getObjectFilterList(self, **kwargs):
        """
        Return a list of names of registered filters.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getObjectFilterListUI(self, **kwargs):
        """
        Return a list of UI names of registered filters.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getObjectFilterShowInHUD(self, **kwargs):
        """
        Sets whether or not to display the object filter UI name in the heads up display when an object filter is active. This string is concatenated with the camera name.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getObjectFilterUI(self, **kwargs):
        """
        Query the current object filter UI name. The object filter is required to have already been registered.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getOcclusionCulling(self, **kwargs):
        """
        Set whether to enable occlusion culling testing when using the hardware renderer. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getParticleInstancers(self, **kwargs):
        """
        Define whether the particle instances should be shown or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getPivots(self, **kwargs):
        """
        Turn on/off the display of transform pivots for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getPlanes(self, **kwargs):
        """
        Turn on/off the display of sketch planes for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getPolymeshes(self, **kwargs):
        """
        Turn on/off the display of polygon meshes for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getQueryPluginObjects(self, **kwargs):
        """
        Query the on/off state of plug-in objects display for the view. To set the on/off state, use -pluginObjects instead.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getRendererDeviceName(self, **kwargs):
        """
        Query for the name of the draw API used by the Viewport 2.0 renderer for a 3d modeling viewport. The possible return values are VirtualDeviceGLif Maya is set to use OpenGL - Legacyfor Viewport 2.0, VirtualDeviceGLCoreif Maya is set to use OpenGL - Core Profile(either Compatibility or Strict) for Viewport 2.0, or VirtualDeviceDx11if Maya is set to use DirectX for Viewport 2.0. If the renderer for the 3d modeling viewport is not Viewport 2.0, an empty string will be returned.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getRendererList(self, **kwargs):
        """
        Query for a list of the internal names for renderers available for use with the 3d modeling viewport. The default list contains at least vp2Renderer, if supported. See rendererName for more details on these renderers. Any plug-in viewport renderers will also appear in this list.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getRendererListUI(self, **kwargs):
        """
        Query for a list of the UI names for renderers available for use with the 3d modeling viewport. The default list consists of the UI name for vp2Renderer, if it is supported. Any plug-in viewport renderer's UI names will also appear in this list. This list and the list returned from rendererList have a 1:1 correspondance.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getRendererName(self, **kwargs):
        """
        Set or get the renderer used for a 3d modeling viewport. The name provided should be an internal name of a renderer. The 'rendererList' flag can be used to query for a list of available names. The default renderer is vp2Renderer: Viewport 2.0.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getRendererOverrideList(self, **kwargs):
        """
        Query for a list of the internal names for renderer overrides for a 3d viewport renderer. Currently only the Viewport 2renderer supports renderer overrides.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getRendererOverrideListUI(self, **kwargs):
        """
        Query for a list of the UI names for renderer overrides for a 3d viewport renderer. Currently only the Viewport 2renderer supports renderer overrides.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getRendererOverrideName(self, **kwargs):
        """
        Set or get the override used for a 3d viewport renderer. The name provided should be the internal name for an override.  The 'rendererOverrideList' flag can be used to query for a list of available names. Currently only the Viewport 2renderer  supports renderer overrides. Setting an empty string will unset any currently active override.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSceneRenderFilter(self, **kwargs):
        """
        Specifies the name of a scene render filter                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSelectionHiliteDisplay(self, **kwargs):
        """
        Sets whether the model panel will draw any selection hiliting on the objects in this window.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getShadingModel(self, **kwargs):
        """
        Shading model to use                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getShadows(self, **kwargs):
        """
        Turn on/off the display of hardware shadows in shaded mode.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSmallObjectCulling(self, **kwargs):
        """
        Define whether small object culling should be enabled or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSmallObjectThreshold(self, **kwargs):
        """
        Threshold used for small object culling                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSmoothWireframe(self, **kwargs):
        """
        Turns on or off smoothing of wireframe lines and points                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSortTransparent(self, **kwargs):
        """
        This flag turns on/off sorting of transparent objects during shaded mode refresh. Normally, objects are sorted according to their origin in camera space but when this flag is turned off they will be drawn according to their (depth-first traversal) order in the scene graph. This is a global flag that affects all model editors.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getStereoDrawMode(self, **kwargs):
        """
        If this flag is used then set stereo draw mode                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getStrokes(self, **kwargs):
        """
        Turn on/off the display of Paint Effects strokes for the view                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getSubdivSurfaces(self, **kwargs):
        """
        Turn on/off the display of subdivision surfaces for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureAnisotropic(self, **kwargs):
        """
        Set whether to perform anisotropic texture filtering. Will work only if the anisotropic texture filtering extension is supported in OpenGL on the graphics system.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureCompression(self, **kwargs):
        """
        Defines whether texture compression should be used or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureDisplay(self, **kwargs):
        """
        Set the type of blending to use for textures. The blend is performed between the destination fragment and the texture fragment. The source is usually the material color. Argument options are: modulate: multiply the destination and texture fragment decal: overwrite the destination with the texture fragment                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureEnvironmentMap(self, **kwargs):
        """
        If true then use a texture environment map                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureHilight(self, **kwargs):
        """
        Set whether to show specular hilighting when the display is in shaded textured mode.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureMaxSize(self, **kwargs):
        """
        Set maximum texture size for hardware texturing.  The integer value must be a power of 2.  Recommended values are 128 or 256.  If the value specified is larger than the OpenGL maximim textures size for the graphics hardware it will be clamped to the OpenGL size.  If many large textures are used in a scene reducing this value improves performance.  On Impact texture memory is pinned in RAM so using large textures can cause reliability and performance problems. Again reducing this value will help. Software rendering does not use this value. This flag is obsolete as of Maya 6.5. The maxTextureResolution/mtr argument on the displayPref command should be used instead.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureMemoryUsed(self, **kwargs):
        """
        Returns the total number of bytes used by all texture maps.  This is typicly width\*height\*channels for all texture objects in the scene If the texture is mip mapped all mip map levels are included in the total though not never more than two level will be in use at one time                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextureSampling(self, **kwargs):
        """
        Set the type of sampling to be used for texture display. The argument can be either: 1 : means to perform point sample2 : means to perform bilinear interpolation (default)
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTextures(self, **kwargs):
        """
        Turn on/off the display of texture objects for the view                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTranspInShadows(self, **kwargs):
        """
        Set whether to enable display of transparency in shadows when using the hardware renderer. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTransparencyAlgorithm(self, **kwargs):
        """
        Set the transparency algorithm. The options are: 1) frontAndBackCull: Two pass front and back culling technique.2) perPolygonSort: Draw transparent polygons in back-to-front order technique.transparency pptions 1) and 2) are supported by the hardware renderer. Options 1) is supported by the interactive modeling viewports. The default value is frontAndBackCull.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getTwoSidedLighting(self, **kwargs):
        """
        Turns on or off two sided lighting.  This may be used with the -default flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getUseBaseRenderer(self, **kwargs):
        """
        Set whether to use the baserenderer when using the hardware renderer and in interactive display mode(-useInteractiveMode) The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getUseColorIndex(self, **kwargs):
        """
        Sets whether the model panel will attempt to use color index mode when possible.  Color index mode can provide a performance increase for point, bounding box, and wireframe display modes. This may be used with the -default flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getUseDefaultMaterial(self, **kwargs):
        """
        Sets whether the model panel will draw all the shaded surfaces using the default material as opposed to using the material(s) currently assigned to the surfaces.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getUseInteractiveMode(self, **kwargs):
        """
        Turns on or off the use of the special interaction settings during playback.  This flag may be used with the -default flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getUseRGBImagePlane(self, **kwargs):
        """
        Sets whether the model panel will be forced into RGB mode when there is an image plane attached to the panel's camera.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getUseReducedRenderer(self, **kwargs):
        """
        Set true if using the reduced renderer                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getUserNode(self, **kwargs):
        """
        Allows the user to associate a node name with the modelEditor. The value is automatically updated in the event the node is deleted or renamed.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getViewObjects(self, **kwargs):
        """
        Returns the name (if any) of the objectSet which contains the list of objects visible in the view if viewSelected is true and the list of objects being displayed does notcome from the active list.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getViewSelected(self, **kwargs):
        """
        This flag turns on/off viewing of selected objects. When the flag is set to true, the currently active objects are captured and used as the list of objects to view.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getViewTransformName(self, **kwargs):
        """
        Sets the view pipeline to be applied if color management is enabled in the current editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getViewType(self, **kwargs):
        """
        Returns a string indicating the type of the model editor. For the default model editor, returns the empty string. For custom model editor types created via the API, returns the same string as is returned via the method MPx3dModelView::viewType().                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getWidth(self, **kwargs):
        """
        Return the width of the associated viewport in pixels.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getWireframeBackingStore(self, **kwargs):
        """
        Sets whether a backing store is used to optimization the drawing of active objects. This mode can provide a performance increase in wireframe mode for certain scenes.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getWireframeOnShaded(self, **kwargs):
        """
        Sets whether the model panel will draw the wireframe on all shaded objects (if true) or only for active objects (if false).                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def getXray(self, **kwargs):
        """
        Turns on or off Xray mode.  This may be used with the -default flag.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def noUndo(self, val='True', **kwargs):
        """
        This flag prevents some viewport operations (such as isolate select) from being added to the undo queue.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def pluginObjects(self, val='True', **kwargs):
        """
        Turn on/off the display of plug-in objects for the view. It depends on the plug-in implementation whether to respect this flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def pluginShapes(self, val='True', **kwargs):
        """
        Turn on/off the display of plug-in shapes for the view. It depends on the plug-in implementation whether to respect this flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def removeSelected(self, val='True', **kwargs):
        """
        This flag causes the currently active objects to be removed from the list of objects visible in the view (if viewSelected is true).                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def resetCustomCamera(self, val='True', **kwargs):
        """
        When specified will reset the camera transform for the active custom camera used for a scene render filter. It is only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveComponentsXray(self, val='True', **kwargs):
        """
        Turns on or off Xray mode for active components.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveCustomGeometry(self, val='True', **kwargs):
        """
        Specifies an identifier for custom geometry to override the geometry to display. It is only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveCustomLighSet(self, val='True', **kwargs):
        """
        Specifies an identifier for the light set to use with a scene render filter. It is only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveCustomOverrideGeometry(self, val='True', **kwargs):
        """
        Specifies an identifier for an override on the custom geometry for a scene render filter.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveCustomRenderer(self, val='True', **kwargs):
        """
        Specifies an identifier for custom renderer to use when a valid scene render filter is also specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveOnly(self, val='True', **kwargs):
        """
        Sets whether only active objects should appear shaded in shaded display.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveShadingGraph(self, val='True', **kwargs):
        """
        Specifies the shading graph to use to override material display. Only enabled when a valid scene render filter is specified.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setActiveView(self, val='True', **kwargs):
        """
        Sets this model editor to be the active view.  Returns true if successful.  On query this flag will return whether the view is the active view.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setAllObjects(self, val='True', **kwargs):
        """
        Turn on/off the display of all objects for the view of the model editor. This excludes NURBS, CVs, hulls, grids and manipulators.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setBackfaceCulling(self, val='True', **kwargs):
        """
        Turns on or off backface culling for the whole view.  This setting overrides the culling settings of individual objects.  All objects draw in the view will be backface culled.  When backface culling is turned on, surfaces becomes invisible in areas where the normal is pointing away from the camera.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setBufferMode(self, val='True', **kwargs):
        """
        Deprecated: this is not supported in Viewport 2.0.  Sets the graphic buffer mode.  Possible values are singleor double.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setBumpResolution(self, val='True', **kwargs):
        """
        Set the resolution for bakedbump map textures when using the hardware renderer. The default value is 512, 512 respectively.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setCamera(self, val='True', **kwargs):
        """
        Change or query the name of the camera in model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setCameraSet(self, val='True', **kwargs):
        """
        Name of the camera set                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setCameras(self, val='True', **kwargs):
        """
        Turn on/off the display of cameras for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setCapture(self, val='True', **kwargs):
        """
        Perform an one-time capture of the viewport to the named image file on disk.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setCaptureSequenceNumber(self, val='True', **kwargs):
        """
        When a number greater or equal to 0 is specified each subsequent refresh will save an image file to disk if the capture flag has been enabled.  The naming of the file is:  {root name}.#.{extension}  if the name {root name}.{extension} is used for the capture flag argument.  The value of # starts at the number specified to for this argument and increments for each subsequent refresh.  Sequence capture can be disabled by specifying a number less than 0 or an empty file name for the capture flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setClipGhosts(self, val='True', **kwargs):
        """
        Define whether the clip ghosts should be added or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setCmEnabled(self, val='True', **kwargs):
        """
        Turn on or off applying color management in the editor.  If set, the color management configuration set in the current editor is used.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setColorResolution(self, val='True', **kwargs):
        """
        Set the resolution for bakedcolor textures when using the hardware renderer. The default value is 256, 256 respectively.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setControlVertices(self, val='True', **kwargs):
        """
        Turn on/off the display of NURBS CVs for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setCullingOverride(self, val='True', **kwargs):
        """
        Set whether to override the culling attributes on objects when using the hardware renderer. The options are: none: Use the culling object attributes per object.doubleSided: Force all objects to be double sided.singleSided: Force all objects to be single sided.The default value is none.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDefault(self, val='True', **kwargs):
        """
        Causes this command to modify the default value of this setting. Newly created model editors will inherit the values.  This flag may be used with the -interactive to set default interactive settings.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDeformers(self, val='True', **kwargs):
        """
        Turn on/off the display of deformer objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDimensions(self, val='True', **kwargs):
        """
        Turn on/off the display of dimension objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDisplayAppearance(self, val='True', **kwargs):
        """
        Sets the display appearance of the model panel.  Possible values are wireframe, points, boundingBox, smoothShaded, flatShaded.  This flag may be used with the -interactive and -default flags.  Note that only wireframe, points, and boundingBoxare valid for the interactive mode.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDisplayLights(self, val='True', **kwargs):
        """
        Sets the lighting for shaded mode.  Possible values are selected, active, all, default, none.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDisplayTextures(self, val='True', **kwargs):
        """
        Turns on or off display of textures in shaded mode                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDynamicConstraints(self, val='True', **kwargs):
        """
        Turn on/off the display of dynamicConstraints for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setDynamics(self, val='True', **kwargs):
        """
        Turn on/off the display of dynamics objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setEditorChanged(self, val='True', **kwargs):
        """
        An optional script callback which is called when the editors options have changed.  This is useful in a situation where a scripted panel contains a modelEditor and wants to be notified when the contained editor changes its options.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setExposure(self, val='True', **kwargs):
        """
        The exposure value used by the color management of the current editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFluids(self, val='True', **kwargs):
        """
        Turn on/off the display of fluids for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFogColor(self, val='True', **kwargs):
        """
        The color used for hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFogDensity(self, val='True', **kwargs):
        """
        Determines the density of hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFogEnd(self, val='True', **kwargs):
        """
        The end location of hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFogMode(self, val='True', **kwargs):
        """
        This determines the drop-off mode for fog. The possibilities are: linear: linear drop-offexponent: exponential drop-offexponent2: squared exponential drop-off
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFogSource(self, val='True', **kwargs):
        """
        Set the type of fog algorithm to use. If the argument is fragment(default) then fog is computed per pixel. If the argument is coordinatethen if the geometry has specified vertex fog coordinates, and the OpenGL extension for vertex fog is supported by the graphics system, then fog is computed per vertex.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFogStart(self, val='True', **kwargs):
        """
        The start location of hardware fogging.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFogging(self, val='True', **kwargs):
        """
        Set whether hardware fogging is enabled or not.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setFollicles(self, val='True', **kwargs):
        """
        Turn on/off the display of follicles for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setGamma(self, val='True', **kwargs):
        """
        The gamma value used by the color management of the current editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setGreasePencils(self, val='True', **kwargs):
        """
        Define whether the grease pencil marks should be added or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setGrid(self, val='True', **kwargs):
        """
        Turn on/off the display of the grid for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setHairSystems(self, val='True', **kwargs):
        """
        Turn on/off the display of hairSystems for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setHandles(self, val='True', **kwargs):
        """
        Turn on/off the display of select handles for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setHeadsUpDisplay(self, val='True', **kwargs):
        """
        Sets whether the model panel will draw any enabled heads up display     elements in this window (if true).  Currently this requires the HUD elements to be globally enabled.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setHulls(self, val='True', **kwargs):
        """
        Turn on/off the display of NURBS hulls for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setIgnorePanZoom(self, val='True', **kwargs):
        """
        Sets whether the model panel will ignore the 2D pan/zoom value to give an overview of the scene.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setIkHandles(self, val='True', **kwargs):
        """
        Turn on/off the display of ik handles and end effectors for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setImagePlane(self, val='True', **kwargs):
        """
        Turn on/off the display of image plane for the view                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setInteractive(self, val='True', **kwargs):
        """
        Causes this command to modify the interactive refresh settings of the view.  In this way it is possible to change the behavior of the model editor during playback for improved performance.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setInteractiveBackFaceCull(self, val='True', **kwargs):
        """
        Define whether interactive backface culling should be on or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setInteractiveDisableShadows(self, val='True', **kwargs):
        """
        Define whether interactive shadows should be disabled or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setJointXray(self, val='True', **kwargs):
        """
        Turns on or off Xray mode for joints.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setJoints(self, val='True', **kwargs):
        """
        Turn on/off the display of joints for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setLights(self, val='True', **kwargs):
        """
        Turn on/off the display of lights for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setLineWidth(self, val='True', **kwargs):
        """
        Set width of lines for display                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setLocators(self, val='True', **kwargs):
        """
        Turn on/off the display of locator objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setLowQualityLighting(self, val='True', **kwargs):
        """
        Set whether to use low quality lightingwhen using the hardware renderer. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setManipulators(self, val='True', **kwargs):
        """
        Turn on/off the display of manipulator objects for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setMaxConstantTransparency(self, val='True', **kwargs):
        """
        Sets the maximum constant transparency.  Setting this value remaps constant transparency values from the range [0.0, 1.0] to the range [0.0, maxConstantTransparency]. All transparency values are shifted linearly to the new range, so a fully transparency object (transparency 1.0) would appear with a transparency of maxConstantTransparency in the viewport, allowing highly transparent objects to be made visible.  This flag only affects constant (non-textured) transparent objects.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setMaximumNumHardwareLights(self, val='True', **kwargs):
        """
        Define whether the hardware light maximum should be respected or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setMotionTrails(self, val='True', **kwargs):
        """
        Turn on/off the Motion Trail display in the Viewport.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setNCloths(self, val='True', **kwargs):
        """
        Turn on/off the display of nCloths for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setNParticles(self, val='True', **kwargs):
        """
        Turn on/off the display of nParticles for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setNRigids(self, val='True', **kwargs):
        """
        Turn on/off the display of nRigids for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setNurbsCurves(self, val='True', **kwargs):
        """
        Turn on/off the display of nurbs curves for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setNurbsSurfaces(self, val='True', **kwargs):
        """
        Turn on/off the display of nurbs surfaces for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setObjectFilter(self, val='True', **kwargs):
        """
        Set or query the current object filter name. An object filter is required to have already been registered.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setObjectFilterShowInHUD(self, val='True', **kwargs):
        """
        Sets whether or not to display the object filter UI name in the heads up display when an object filter is active. This string is concatenated with the camera name.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setOcclusionCulling(self, val='True', **kwargs):
        """
        Set whether to enable occlusion culling testing when using the hardware renderer. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setParticleInstancers(self, val='True', **kwargs):
        """
        Define whether the particle instances should be shown or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setPivots(self, val='True', **kwargs):
        """
        Turn on/off the display of transform pivots for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setPlanes(self, val='True', **kwargs):
        """
        Turn on/off the display of sketch planes for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setPolymeshes(self, val='True', **kwargs):
        """
        Turn on/off the display of polygon meshes for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setRendererName(self, val='True', **kwargs):
        """
        Set or get the renderer used for a 3d modeling viewport. The name provided should be an internal name of a renderer. The 'rendererList' flag can be used to query for a list of available names. The default renderer is vp2Renderer: Viewport 2.0.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setRendererOverrideName(self, val='True', **kwargs):
        """
        Set or get the override used for a 3d viewport renderer. The name provided should be the internal name for an override.  The 'rendererOverrideList' flag can be used to query for a list of available names. Currently only the Viewport 2renderer  supports renderer overrides. Setting an empty string will unset any currently active override.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSceneRenderFilter(self, val='True', **kwargs):
        """
        Specifies the name of a scene render filter                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSelected(self, val='True', **kwargs):
        """
        This flag causes the currently active objects to be the only objects visible in the view (if viewSelected is true).                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSelectionHiliteDisplay(self, val='True', **kwargs):
        """
        Sets whether the model panel will draw any selection hiliting on the objects in this window.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setShadingModel(self, val='True', **kwargs):
        """
        Shading model to use                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setShadows(self, val='True', **kwargs):
        """
        Turn on/off the display of hardware shadows in shaded mode.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSmallObjectCulling(self, val='True', **kwargs):
        """
        Define whether small object culling should be enabled or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSmallObjectThreshold(self, val='True', **kwargs):
        """
        Threshold used for small object culling                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSmoothWireframe(self, val='True', **kwargs):
        """
        Turns on or off smoothing of wireframe lines and points                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSortTransparent(self, val='True', **kwargs):
        """
        This flag turns on/off sorting of transparent objects during shaded mode refresh. Normally, objects are sorted according to their origin in camera space but when this flag is turned off they will be drawn according to their (depth-first traversal) order in the scene graph. This is a global flag that affects all model editors.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setStereoDrawMode(self, val='True', **kwargs):
        """
        If this flag is used then set stereo draw mode                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setStrokes(self, val='True', **kwargs):
        """
        Turn on/off the display of Paint Effects strokes for the view                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setSubdivSurfaces(self, val='True', **kwargs):
        """
        Turn on/off the display of subdivision surfaces for the view of the model editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextureAnisotropic(self, val='True', **kwargs):
        """
        Set whether to perform anisotropic texture filtering. Will work only if the anisotropic texture filtering extension is supported in OpenGL on the graphics system.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextureCompression(self, val='True', **kwargs):
        """
        Defines whether texture compression should be used or not                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextureDisplay(self, val='True', **kwargs):
        """
        Set the type of blending to use for textures. The blend is performed between the destination fragment and the texture fragment. The source is usually the material color. Argument options are: modulate: multiply the destination and texture fragment decal: overwrite the destination with the texture fragment                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextureEnvironmentMap(self, val='True', **kwargs):
        """
        If true then use a texture environment map                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextureHilight(self, val='True', **kwargs):
        """
        Set whether to show specular hilighting when the display is in shaded textured mode.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextureMaxSize(self, val='True', **kwargs):
        """
        Set maximum texture size for hardware texturing.  The integer value must be a power of 2.  Recommended values are 128 or 256.  If the value specified is larger than the OpenGL maximim textures size for the graphics hardware it will be clamped to the OpenGL size.  If many large textures are used in a scene reducing this value improves performance.  On Impact texture memory is pinned in RAM so using large textures can cause reliability and performance problems. Again reducing this value will help. Software rendering does not use this value. This flag is obsolete as of Maya 6.5. The maxTextureResolution/mtr argument on the displayPref command should be used instead.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextureSampling(self, val='True', **kwargs):
        """
        Set the type of sampling to be used for texture display. The argument can be either: 1 : means to perform point sample2 : means to perform bilinear interpolation (default)
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTextures(self, val='True', **kwargs):
        """
        Turn on/off the display of texture objects for the view                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTranspInShadows(self, val='True', **kwargs):
        """
        Set whether to enable display of transparency in shadows when using the hardware renderer. The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTransparencyAlgorithm(self, val='True', **kwargs):
        """
        Set the transparency algorithm. The options are: 1) frontAndBackCull: Two pass front and back culling technique.2) perPolygonSort: Draw transparent polygons in back-to-front order technique.transparency pptions 1) and 2) are supported by the hardware renderer. Options 1) is supported by the interactive modeling viewports. The default value is frontAndBackCull.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setTwoSidedLighting(self, val='True', **kwargs):
        """
        Turns on or off two sided lighting.  This may be used with the -default flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setUseBaseRenderer(self, val='True', **kwargs):
        """
        Set whether to use the baserenderer when using the hardware renderer and in interactive display mode(-useInteractiveMode) The default value is false.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setUseColorIndex(self, val='True', **kwargs):
        """
        Sets whether the model panel will attempt to use color index mode when possible.  Color index mode can provide a performance increase for point, bounding box, and wireframe display modes. This may be used with the -default flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setUseDefaultMaterial(self, val='True', **kwargs):
        """
        Sets whether the model panel will draw all the shaded surfaces using the default material as opposed to using the material(s) currently assigned to the surfaces.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setUseInteractiveMode(self, val='True', **kwargs):
        """
        Turns on or off the use of the special interaction settings during playback.  This flag may be used with the -default flag.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setUseRGBImagePlane(self, val='True', **kwargs):
        """
        Sets whether the model panel will be forced into RGB mode when there is an image plane attached to the panel's camera.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setUseReducedRenderer(self, val='True', **kwargs):
        """
        Set true if using the reduced renderer                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setUserNode(self, val='True', **kwargs):
        """
        Allows the user to associate a node name with the modelEditor. The value is automatically updated in the event the node is deleted or renamed.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setViewSelected(self, val='True', **kwargs):
        """
        This flag turns on/off viewing of selected objects. When the flag is set to true, the currently active objects are captured and used as the list of objects to view.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setViewTransformName(self, val='True', **kwargs):
        """
        Sets the view pipeline to be applied if color management is enabled in the current editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setWireframeBackingStore(self, val='True', **kwargs):
        """
        Sets whether a backing store is used to optimization the drawing of active objects. This mode can provide a performance increase in wireframe mode for certain scenes.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setWireframeOnShaded(self, val='True', **kwargs):
        """
        Sets whether the model panel will draw the wireframe on all shaded objects (if true) or only for active objects (if false).                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def setXray(self, val='True', **kwargs):
        """
        Turns on or off Xray mode.  This may be used with the -default flag.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def toggleExposure(self, val='True', **kwargs):
        """
        Toggles between the current and the default exposure value of the editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def toggleGamma(self, val='True', **kwargs):
        """
        Toggles between the current and the default gamma value of the editor.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def updateColorMode(self, val='True', **kwargs):
        """
        Using this flag tells the model panel to check which color mode it should be in, and to switch accordingly.  This flag may be used to update a model panel after a camera image plane has been added or removed.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create, edit or query a model editor. Note that some of the flags of this
        command may have different settings for normal mode and for interactive/playback
        mode.  For example, a modelEditor can be set to use shaded mode normally, but to
        use wireframe during playback for greater speed.  Some flags also support having
        defaults set so that new model editors will be created with those settings.
        
        Flags:
        - activeComponentsXray : acx     (bool)          [query,edit]
            Turns on or off Xray mode for active components.
        
        - activeCustomEnvironment : ace  (unicode)       [edit]
            Specifies a path to an image file to be used as environment map. It is only
            enabled when a valid scene render filter is specified.
        
        - activeCustomGeometry : acg     (unicode)       [query,edit]
            Specifies an identifier for custom geometry to override the geometry to display.
            It is only enabled when a valid scene render filter is specified.
        
        - activeCustomLighSet : acl      (unicode)       [query,edit]
            Specifies an identifier for the light set to use with a scene render filter. It
            is only enabled when a valid scene render filter is specified.
        
        - activeCustomOverrideGeometry : aog (unicode)       [query,edit]
            Specifies an identifier for an override on the custom geometry for a scene
            render filter.
        
        - activeCustomRenderer : acr     (unicode)       [query,edit]
            Specifies an identifier for custom renderer to use when a valid scene render
            filter is also specified.
        
        - activeOnly : ao                (bool)          [query,edit]
            Sets whether only active objects should appear shaded in shaded display.
        
        - activeShadingGraph : asg       (unicode)       [query,edit]
            Specifies the shading graph to use to override material display. Only enabled
            when a valid scene render filter is specified.
        
        - activeView : av                (bool)          [query,edit]
            Sets this model editor to be the active view.  Returns true if successful.  On
            query this flag will return whether the view is the active view.
        
        - addObjects : aob               (unicode)       [edit]
            This flag causes the objects contained within the selection connection to be
            added to the list of objects visible in the view (if viewSelected is true).
        
        - addSelected : addSelected      (bool)          [edit]
            This flag causes the currently active objects to be added to the list of objects
            visible in the view (if viewSelected is true).
        
        - addSelectedObjects : aso       (bool)          [create]
            If set then add the selected objects to the editor
        
        - allObjects : alo               (bool)          [query,edit]
            Turn on/off the display of all objects for the view of the model editor. This
            excludes NURBS, CVs, hulls, grids and manipulators.
        
        - backfaceCulling : bfc          (bool)          [query,edit]
            Turns on or off backface culling for the whole view.  This setting overrides the
            culling settings of individual objects.  All objects draw in the view will be
            backface culled.  When backface culling is turned on, surfaces becomes invisible
            in areas where the normal is pointing away from the camera.
        
        - bufferMode : bm                (unicode)       [query,edit]
            Deprecated: this is not supported in Viewport 2.0.  Sets the graphic buffer
            mode.  Possible values are singleor double.
        
        - bumpResolution : brz           (int, int)      [query,edit]
            Set the resolution for bakedbump map textures when using the hardware renderer.
            The default value is 512, 512 respectively.
        
        - camera : cam                   (unicode)       [query,edit]
            Change or query the name of the camera in model editor.
        
        - cameraName : cn                (unicode)       [create,edit]
            Set the name of the panel's camera transform and shape. The shape name is
            computed by appending the string Shapeto the transform name. This flag may not
            be queried.
        
        - cameraSet : cst                (unicode)       [create,query,edit]
            Name of the camera set
        
        - cameraSetup : cs               (bool)          [query]
            Based on the model editor name passed in will returns a string list containing
            camera setups. A camera setup can contain one or more cameras which are
            associated with each other. Camera setups are defined as pairs of consecutive
            strings in the list. Each pair is comprised of: a string which identifies an
            active camera, and a string which defines a script to set up a given active
            camera. As many pairs of strings can be returned as the number of active
            cameras. If nothing is returned then it is assumed that no set up is required to
            activate a given camera.
        
        - cameras : ca                   (bool)          [query,edit]
            Turn on/off the display of cameras for the view of the model editor.
        
        - capture : cpt                  (unicode)       [query,edit]
            Perform an one-time capture of the viewport to the named image file on disk.
        
        - captureSequenceNumber : csn    (int)           [query,edit]
            When a number greater or equal to 0 is specified each subsequent refresh will
            save an image file to disk if the capture flag has been enabled.  The naming of
            the file is:  {root name}.#.{extension}  if the name {root name}.{extension} is
            used for the capture flag argument.  The value of # starts at the number
            specified to for this argument and increments for each subsequent refresh.
            Sequence capture can be disabled by specifying a number less than 0 or an empty
            file name for the capture flag.
        
        - clipGhosts : cg                (bool)          [create,query,edit]
            Define whether the clip ghosts should be added or not
        
        - cmEnabled : cme                (bool)          [query,edit]
            Turn on or off applying color management in the editor.  If set, the color
            management configuration set in the current editor is used.
        
        - colorMap : cm                  (bool)          [query]
            Queries the color map style for the model panel. Possible values are
            colorIndexand rgb.
        
        - colorResolution : crz          (int, int)      [query,edit]
            Set the resolution for bakedcolor textures when using the hardware renderer. The
            default value is 256, 256 respectively.
        
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - controlVertices : cv           (bool)          [query,edit]
            Turn on/off the display of NURBS CVs for the view of the model editor.
        
        - controllers : cts              (bool)          []
        
        - cullingOverride : cov          (unicode)       [query,edit]
            Set whether to override the culling attributes on objects when using the
            hardware renderer. The options are: none: Use the culling object attributes per
            object.doubleSided: Force all objects to be double sided.singleSided: Force all
            objects to be single sided.The default value is none.
        
        - default : d                    (bool)          [query,edit]
            Causes this command to modify the default value of this setting. Newly created
            model editors will inherit the values.  This flag may be used with the
            -interactive to set default interactive settings.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deformers : df                 (bool)          [query,edit]
            Turn on/off the display of deformer objects for the view of the model editor.
        
        - depthOfFieldPreview : dof      (bool)          []
        
        - dimensions : dim               (bool)          [query,edit]
            Turn on/off the display of dimension objects for the view of the model editor.
        
        - displayAppearance : da         (unicode)       [query,edit]
            Sets the display appearance of the model panel.  Possible values are wireframe,
            points, boundingBox, smoothShaded, flatShaded.  This flag may be used with the
            -interactive and -default flags.  Note that only wireframe, points, and
            boundingBoxare valid for the interactive mode.
        
        - displayLights : dl             (unicode)       [query,edit]
            Sets the lighting for shaded mode.  Possible values are selected, active, all,
            default, none.
        
        - displayTextures : dtx          (bool)          [query,edit]
            Turns on or off display of textures in shaded mode
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - dynamicConstraints : dc        (bool)          [query,edit]
            Turn on/off the display of dynamicConstraints for the view of the model editor.
        
        - dynamics : dy                  (bool)          [query,edit]
            Turn on/off the display of dynamics objects for the view of the model editor.
        
        - editorChanged : ec             (script)        [create,query,edit]
            An optional script callback which is called when the editors options have
            changed.  This is useful in a situation where a scripted panel contains a
            modelEditor and wants to be notified when the contained editor changes its
            options.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - exposure : exp                 (float)         [query,edit]
            The exposure value used by the color management of the current editor.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - filteredObjectList : fol       (bool)          [query]
            For model editors with filtering on (either using an object filter, or isolate
            select), this flag returns a string list of the objects which are displayed in
            this editor. Note that this list does not take into account visibility (based on
            camera frustum or flags), it purely captures the objects which are considered
            when rendering the view.
        
        - fluids : fl                    (bool)          [query,edit]
            Turn on/off the display of fluids for the view of the model editor.
        
        - fogColor : fcl                 (float, float, float, float) [query,edit]
            The color used for hardware fogging.
        
        - fogDensity : fdn               (float)         [query,edit]
            Determines the density of hardware fogging.
        
        - fogEnd : fen                   (float)         [query,edit]
            The end location of hardware fogging.
        
        - fogMode : fmd                  (unicode)       [query,edit]
            This determines the drop-off mode for fog. The possibilities are: linear: linear
            drop-offexponent: exponential drop-offexponent2: squared exponential drop-off
        
        - fogSource : fsc                (unicode)       [query,edit]
            Set the type of fog algorithm to use. If the argument is fragment(default) then
            fog is computed per pixel. If the argument is coordinatethen if the geometry has
            specified vertex fog coordinates, and the OpenGL extension for vertex fog is
            supported by the graphics system, then fog is computed per vertex.
        
        - fogStart : fst                 (float)         [query,edit]
            The start location of hardware fogging.
        
        - fogging : fg                   (bool)          [query,edit]
            Set whether hardware fogging is enabled or not.
        
        - follicles : fo                 (bool)          [query,edit]
            Turn on/off the display of follicles for the view of the model editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - gamma : ga                     (float)         [query,edit]
            The gamma value used by the color management of the current editor.
        
        - greasePencils : gp             (bool)          [create,query,edit]
            Define whether the grease pencil marks should be added or not
        
        - grid : gr                      (bool)          [query,edit]
            Turn on/off the display of the grid for the view of the model editor.
        
        - hairSystems : hs               (bool)          [query,edit]
            Turn on/off the display of hairSystems for the view of the model editor.
        
        - handles : ha                   (bool)          [query,edit]
            Turn on/off the display of select handles for the view of the model editor.
        
        - headsUpDisplay : hud           (bool)          [query,edit]
            Sets whether the model panel will draw any enabled heads up display     elements
            in this window (if true).  Currently this requires the HUD elements to be
            globally enabled.
        
        - height : h                     (bool)          [query]
            Return the height of the associated viewport in pixels
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - holdOuts : hos                 (bool)          []
        
        - hulls : hu                     (bool)          [query,edit]
            Turn on/off the display of NURBS hulls for the view of the model editor.
        
        - ignorePanZoom : ipz            (bool)          [query,edit]
            Sets whether the model panel will ignore the 2D pan/zoom value to give an
            overview of the scene.
        
        - ikHandles : ikh                (bool)          [query,edit]
            Turn on/off the display of ik handles and end effectors for the view of the
            model editor.
        
        - imagePlane : imp               (bool)          [query,edit]
            Turn on/off the display of image plane for the view
        
        - interactive : i                (bool)          [query,edit]
            Causes this command to modify the interactive refresh settings of the view.  In
            this way it is possible to change the behavior of the model editor during
            playback for improved performance.
        
        - interactiveBackFaceCull : ibc  (bool)          [create,query,edit]
            Define whether interactive backface culling should be on or not
        
        - interactiveDisableShadows : dis (bool)          [create,query,edit]
            Define whether interactive shadows should be disabled or not
        
        - isFiltered : isFiltered        (bool)          [query]
            Returns true for model editors with filtering applied to their view of the
            scene. This could either be an explicit object filter, or a display option such
            as isolate select which filters the objects that are displayed.
        
        - jointXray : jx                 (bool)          [query,edit]
            Turns on or off Xray mode for joints.
        
        - joints : j                     (bool)          [query,edit]
            Turn on/off the display of joints for the view of the model editor.
        
        - lights : lt                    (bool)          [query,edit]
            Turn on/off the display of lights for the view of the model editor.
        
        - lineWidth : lw                 (float)         [query,edit]
            Set width of lines for display
        
        - locators : lc                  (bool)          [query,edit]
            Turn on/off the display of locator objects for the view of the model editor.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - lowQualityLighting : lql       (bool)          [query,edit]
            Set whether to use low quality lightingwhen using the hardware renderer. The
            default value is false.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - manipulators : m               (bool)          [query,edit]
            Turn on/off the display of manipulator objects for the view of the model editor.
        
        - maxConstantTransparency : mct  (float)         [query,edit]
            Sets the maximum constant transparency.  Setting this value remaps constant
            transparency values from the range [0.0, 1.0] to the range [0.0,
            maxConstantTransparency]. All transparency values are shifted linearly to the
            new range, so a fully transparency object (transparency 1.0) would appear with a
            transparency of maxConstantTransparency in the viewport, allowing highly
            transparent objects to be made visible.  This flag only affects constant (non-
            textured) transparent objects.
        
        - maximumNumHardwareLights : mhl (bool)          [create,query,edit]
            Define whether the hardware light maximum should be respected or not
        
        - modelPanel : mp                (unicode)       [create]
            Allows the created model editor to be embedded in the named model panel.
            Intended for use with custom model editors created via the API (i.e. the flag
            would be used on the derived MPxModelEditorCommand), though the flag may also be
            used on the base modelEditor command to restore a default Maya model editor to
            the panel. Note that the model editor previously owned by the panel is deleted.
        
        - motionTrails : mt              (bool)          [query,edit]
            Turn on/off the Motion Trail display in the Viewport.
        
        - nCloths : ncl                  (bool)          [query,edit]
            Turn on/off the display of nCloths for the view of the model editor.
        
        - nParticles : npa               (bool)          [query,edit]
            Turn on/off the display of nParticles for the view of the model editor.
        
        - nRigids : nr                   (bool)          [query,edit]
            Turn on/off the display of nRigids for the view of the model editor.
        
        - noUndo : nud                   (bool)          [edit]
            This flag prevents some viewport operations (such as isolate select) from being
            added to the undo queue.
        
        - nurbsCurves : nc               (bool)          [query,edit]
            Turn on/off the display of nurbs curves for the view of the model editor.
        
        - nurbsSurfaces : ns             (bool)          [query,edit]
            Turn on/off the display of nurbs surfaces for the view of the model editor.
        
        - objectFilter : obf             (script)        [query,edit]
            Set or query the current object filter name. An object filter is required to
            have already been registered.
        
        - objectFilterList : ofl         (script)        [query]
            Return a list of names of registered filters.
        
        - objectFilterListUI : ofu       (script)        [query]
            Return a list of UI names of registered filters.
        
        - objectFilterShowInHUD : ofs    (bool)          [query,edit]
            Sets whether or not to display the object filter UI name in the heads up display
            when an object filter is active. This string is concatenated with the camera
            name.
        
        - objectFilterUI : obu           (script)        [query]
            Query the current object filter UI name. The object filter is required to have
            already been registered.
        
        - occlusionCulling : ocl         (bool)          [query,edit]
            Set whether to enable occlusion culling testing when using the hardware
            renderer. The default value is false.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - particleInstancers : pi        (bool)          [create,query,edit]
            Define whether the particle instances should be shown or not
        
        - pivots : pv                    (bool)          [query,edit]
            Turn on/off the display of transform pivots for the view of the model editor.
        
        - planes : pl                    (bool)          [query,edit]
            Turn on/off the display of sketch planes for the view of the model editor.
        
        - pluginObjects : po             (unicode, bool) [edit]
            Turn on/off the display of plug-in objects for the view. It depends on the plug-
            in implementation whether to respect this flag.
        
        - pluginShapes : ps              (bool)          [edit]
            Turn on/off the display of plug-in shapes for the view. It depends on the plug-
            in implementation whether to respect this flag.
        
        - polymeshes : pm                (bool)          [query,edit]
            Turn on/off the display of polygon meshes for the view of the model editor.
        
        - queryPluginObjects : qpo       (unicode)       [query]
            Query the on/off state of plug-in objects display for the view. To set the
            on/off state, use -pluginObjects instead.
        
        - removeSelected : rs            (bool)          [edit]
            This flag causes the currently active objects to be removed from the list of
            objects visible in the view (if viewSelected is true).
        
        - rendererDeviceName : rdn       (bool)          [query]
            Query for the name of the draw API used by the Viewport 2.0 renderer for a 3d
            modeling viewport. The possible return values are VirtualDeviceGLif Maya is set
            to use OpenGL - Legacyfor Viewport 2.0, VirtualDeviceGLCoreif Maya is set to use
            OpenGL - Core Profile(either Compatibility or Strict) for Viewport 2.0, or
            VirtualDeviceDx11if Maya is set to use DirectX for Viewport 2.0. If the renderer
            for the 3d modeling viewport is not Viewport 2.0, an empty string will be
            returned.
        
        - rendererList : rls             (bool)          [query]
            Query for a list of the internal names for renderers available for use with the
            3d modeling viewport. The default list contains at least vp2Renderer, if
            supported. See rendererName for more details on these renderers. Any plug-in
            viewport renderers will also appear in this list.
        
        - rendererListUI : rlu           (bool)          [query]
            Query for a list of the UI names for renderers available for use with the 3d
            modeling viewport. The default list consists of the UI name for vp2Renderer, if
            it is supported. Any plug-in viewport renderer's UI names will also appear in
            this list. This list and the list returned from rendererList have a 1:1
            correspondance.
        
        - rendererName : rnm             (unicode)       [query,edit]
            Set or get the renderer used for a 3d modeling viewport. The name provided
            should be an internal name of a renderer. The 'rendererList' flag can be used to
            query for a list of available names. The default renderer is vp2Renderer:
            Viewport 2.0.
        
        - rendererOverrideList : rol     (bool)          [query]
            Query for a list of the internal names for renderer overrides for a 3d viewport
            renderer. Currently only the Viewport 2renderer supports renderer overrides.
        
        - rendererOverrideListUI : rou   (bool)          [query]
            Query for a list of the UI names for renderer overrides for a 3d viewport
            renderer. Currently only the Viewport 2renderer supports renderer overrides.
        
        - rendererOverrideName : rom     (unicode)       [query,edit]
            Set or get the override used for a 3d viewport renderer. The name provided
            should be the internal name for an override.  The 'rendererOverrideList' flag
            can be used to query for a list of available names. Currently only the Viewport
            2renderer  supports renderer overrides. Setting an empty string will unset any
            currently active override.
        
        - resetCustomCamera : rcc        (bool)          [edit]
            When specified will reset the camera transform for the active custom camera used
            for a scene render filter. It is only enabled when a valid scene render filter
            is specified.
        
        - sceneRenderFilter : srf        (unicode)       [query,edit]
            Specifies the name of a scene render filter
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - selectionHiliteDisplay : sel   (bool)          [query,edit]
            Sets whether the model panel will draw any selection hiliting on the objects in
            this window.
        
        - setSelected : ss               (bool)          [edit]
            This flag causes the currently active objects to be the only objects visible in
            the view (if viewSelected is true).
        
        - shadingModel : sml             (int)           [create,query,edit]
            Shading model to use
        
        - shadows : sdw                  (bool)          [query,edit]
            Turn on/off the display of hardware shadows in shaded mode.
        
        - smallObjectCulling : soc       (bool)          [create,query,edit]
            Define whether small object culling should be enabled or not
        
        - smallObjectThreshold : sot     (float)         [create,query,edit]
            Threshold used for small object culling
        
        - smoothWireframe : swf          (bool)          [query,edit]
            Turns on or off smoothing of wireframe lines and points
        
        - sortTransparent : st           (bool)          [query,edit]
            This flag turns on/off sorting of transparent objects during shaded mode
            refresh. Normally, objects are sorted according to their origin in camera space
            but when this flag is turned off they will be drawn according to their (depth-
            first traversal) order in the scene graph. This is a global flag that affects
            all model editors.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - stereoDrawMode : sdm           (bool)          [create,query,edit]
            If this flag is used then set stereo draw mode
        
        - strokes : str                  (bool)          [query,edit]
            Turn on/off the display of Paint Effects strokes for the view
        
        - subdivSurfaces : sds           (bool)          [query,edit]
            Turn on/off the display of subdivision surfaces for the view of the model
            editor.
        
        - textureAnisotropic : ta        (bool)          [query,edit]
            Set whether to perform anisotropic texture filtering. Will work only if the
            anisotropic texture filtering extension is supported in OpenGL on the graphics
            system.
        
        - textureCompression : tcp       (bool)          [create,query,edit]
            Defines whether texture compression should be used or not
        
        - textureDisplay : td            (unicode)       [query,edit]
            Set the type of blending to use for textures. The blend is performed between the
            destination fragment and the texture fragment. The source is usually the
            material color. Argument options are: modulate: multiply the destination and
            texture fragment decal: overwrite the destination with the texture fragment
        
        - textureEnvironmentMap : tem    (bool)          [create,query,edit]
            If true then use a texture environment map
        
        - textureHilight : th            (bool)          [query,edit]
            Set whether to show specular hilighting when the display is in shaded textured
            mode.
        
        - textureMaxSize : tms           (int)           [query,edit]
            Set maximum texture size for hardware texturing.  The integer value must be a
            power of 2.  Recommended values are 128 or 256.  If the value specified is
            larger than the OpenGL maximim textures size for the graphics hardware it will
            be clamped to the OpenGL size.  If many large textures are used in a scene
            reducing this value improves performance.  On Impact texture memory is pinned in
            RAM so using large textures can cause reliability and performance problems.
            Again reducing this value will help. Software rendering does not use this value.
            This flag is obsolete as of Maya 6.5. The maxTextureResolution/mtr argument on
            the displayPref command should be used instead.
        
        - textureMemoryUsed : tmu        (bool)          [query]
            Returns the total number of bytes used by all texture maps.  This is typicly
            width\*height\*channels for all texture objects in the scene If the texture is
            mip mapped all mip map levels are included in the total though not never more
            than two level will be in use at one time
        
        - textureSampling : ts           (int)           [query,edit]
            Set the type of sampling to be used for texture display. The argument can be
            either: 1 : means to perform point sample2 : means to perform bilinear
            interpolation (default)
        
        - textures : tx                  (bool)          [query,edit]
            Turn on/off the display of texture objects for the view
        
        - toggleExposure : tge           (bool)          [edit]
            Toggles between the current and the default exposure value of the editor.
        
        - toggleGamma : tgg              (bool)          [edit]
            Toggles between the current and the default gamma value of the editor.
        
        - transpInShadows : tis          (bool)          [query,edit]
            Set whether to enable display of transparency in shadows when using the hardware
            renderer. The default value is false.
        
        - transparencyAlgorithm : tal    (unicode)       [query,edit]
            Set the transparency algorithm. The options are: 1) frontAndBackCull: Two pass
            front and back culling technique.2) perPolygonSort: Draw transparent polygons in
            back-to-front order technique.transparency pptions 1) and 2) are supported by
            the hardware renderer. Options 1) is supported by the interactive modeling
            viewports. The default value is frontAndBackCull.
        
        - twoSidedLighting : tsl         (bool)          [query,edit]
            Turns on or off two sided lighting.  This may be used with the -default flag.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateColorMode : ucm          (bool)          [edit]
            Using this flag tells the model panel to check which color mode it should be in,
            and to switch accordingly.  This flag may be used to update a model panel after
            a camera image plane has been added or removed.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useBaseRenderer : ubr          (bool)          [query,edit]
            Set whether to use the baserenderer when using the hardware renderer and in
            interactive display mode(-useInteractiveMode) The default value is false.
        
        - useColorIndex : uci            (bool)          [query,edit]
            Sets whether the model panel will attempt to use color index mode when possible.
            Color index mode can provide a performance increase for point, bounding box, and
            wireframe display modes. This may be used with the -default flag.
        
        - useDefaultMaterial : udm       (bool)          [query,edit]
            Sets whether the model panel will draw all the shaded surfaces using the default
            material as opposed to using the material(s) currently assigned to the surfaces.
        
        - useInteractiveMode : ui        (bool)          [query,edit]
            Turns on or off the use of the special interaction settings during playback.
            This flag may be used with the -default flag.
        
        - useRGBImagePlane : ip          (bool)          [query,edit]
            Sets whether the model panel will be forced into RGB mode when there is an image
            plane attached to the panel's camera.
        
        - useReducedRenderer : urr       (bool)          [create,query,edit]
            Set true if using the reduced renderer
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - userNode : un                  (unicode)       [query,edit]
            Allows the user to associate a node name with the modelEditor. The value is
            automatically updated in the event the node is deleted or renamed.
        
        - viewObjects : vo               (bool)          [query]
            Returns the name (if any) of the objectSet which contains the list of objects
            visible in the view if viewSelected is true and the list of objects being
            displayed does notcome from the active list.
        
        - viewSelected : vs              (bool)          [query,edit]
            This flag turns on/off viewing of selected objects. When the flag is set to
            true, the currently active objects are captured and used as the list of objects
            to view.
        
        - viewTransformName : vtn        (unicode)       [query,edit]
            Sets the view pipeline to be applied if color management is enabled in the
            current editor.
        
        - viewType : vt                  (bool)          [query]
            Returns a string indicating the type of the model editor. For the default model
            editor, returns the empty string. For custom model editor types created via the
            API, returns the same string as is returned via the method
            MPx3dModelView::viewType().
        
        - width : w                      (bool)          [query]
            Return the width of the associated viewport in pixels.
        
        - wireframeBackingStore : wbs    (bool)          [query,edit]
            Sets whether a backing store is used to optimization the drawing of active
            objects. This mode can provide a performance increase in wireframe mode for
            certain scenes.
        
        - wireframeOnShaded : wos        (bool)          [query,edit]
            Sets whether the model panel will draw the wireframe on all shaded objects (if
            true) or only for active objects (if false).
        
        - xray : xr                      (bool)          [query,edit]
            Turns on or off Xray mode.  This may be used with the -default flag.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.modelEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'modelEditor'
    
    
    __melui__ = 'modelEditor'


class FloatSlider(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes.  This command is not invoked when the value changes via the -v/value flag.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes by dragging the slider's value marker.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getHorizontal(self, **kwargs):
        """
        Orientation of the slider.  This flag is true by default, which corresponds to a horizontally oriented slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Upper limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Lower limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getStep(self, **kwargs):
        """
        The step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Upper limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Lower limit of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        The step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a slider control that accepts only float values and is bound by a minimum
        and maximum value.  The slider displays a marker indicating the current value of
        the slider relative to its minimum and maximum values.  Click and drag the
        marker, or on the slider itself to change the current value.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the value changes.  This command is not invoked when the
            value changes via the -v/value flag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command executed when the value changes by dragging the slider's value marker.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontal : hr                (bool)          [create,query]
            Orientation of the slider.  This flag is true by default, which corresponds to a
            horizontally oriented slider.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (float)         [create,query,edit]
            Upper limit of the slider.
        
        - minValue : min                 (float)         [create,query,edit]
            Lower limit of the slider.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            The step value represents the amount the value will increase or decrease when
            you click either side of the slider.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (float)         [create,query,edit]
            Value of the slider.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.floatSlider`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'floatSlider'
    
    
    __melui__ = 'floatSlider'


class ProgressBar(PyUI):
    def beginProgress(self, val='True', **kwargs):
        """
        Only valid for the main progress barShows the main progress bar (normally in the Help Line). This is normally issued through MEL when a length computation is about to occur.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def endProgress(self, val='True', **kwargs):
        """
        Only valid for the main progress barHides the progress bar. No other flags can be used at the same time. This is normally issued through MEL in response to the -ic/isCancelled flag being set or if the progress value reaches its maximum.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getIsCancelled(self, **kwargs):
        """
        Returns true if the user has tried to cancel the operation. Returns false otherwise.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getIsInterruptable(self, **kwargs):
        """
        Only valid for the main progress barReturns true if the isCancelled flag should respond to attempts to cancel the operation. Setting this to true will add a note in the help line display message to the user indicating that they can cancel the operation.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getIsMainProgressBar(self, **kwargs):
        """
        Determines whether this progressBar is used to show the progress of all basic operations such as Open/Save file.The main progressBar behaves very differently, in that it only shows itself when there is an ongoing basic operation.Defaults to false, and only one progress bar will be recognized as the mainone.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        The maximum or endingvalue of the progress indicator. If the progress value is greater than the -max/maxValue, the progress value will be set to the maximum. Default value is 100.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        The minimum or startingvalue of the progress indicator. If the progress value is less than the -min/minValue, the progress value will be set to the minimum. Default value is 0.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getProgress(self, **kwargs):
        """
        The amount of progress currently shown on the control. The value will always be between min and max. Default is equal to the minimum when the control is created.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getStatus(self, **kwargs):
        """
        Only valid for the main progress barSets the contents of the helpLine control when the progressBar is showing. Use this instead of setting the helpLine directly because this will force a graphical refresh before returning.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setIsInterruptable(self, val='True', **kwargs):
        """
        Only valid for the main progress barReturns true if the isCancelled flag should respond to attempts to cancel the operation. Setting this to true will add a note in the help line display message to the user indicating that they can cancel the operation.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setIsMainProgressBar(self, val='True', **kwargs):
        """
        Determines whether this progressBar is used to show the progress of all basic operations such as Open/Save file.The main progressBar behaves very differently, in that it only shows itself when there is an ongoing basic operation.Defaults to false, and only one progress bar will be recognized as the mainone.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        The maximum or endingvalue of the progress indicator. If the progress value is greater than the -max/maxValue, the progress value will be set to the maximum. Default value is 100.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        The minimum or startingvalue of the progress indicator. If the progress value is less than the -min/minValue, the progress value will be set to the minimum. Default value is 0.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setProgress(self, val='True', **kwargs):
        """
        The amount of progress currently shown on the control. The value will always be between min and max. Default is equal to the minimum when the control is created.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setStatus(self, val='True', **kwargs):
        """
        Only valid for the main progress barSets the contents of the helpLine control when the progressBar is showing. Use this instead of setting the helpLine directly because this will force a graphical refresh before returning.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    def step(self, val='True', **kwargs):
        """
        Increments the -pr/progress value by the amount specified.                  
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Creates a progress bar control that graphically fills in as its progress value
        increases.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - beginProgress : bp             (bool)          [create,edit]
            Only valid for the main progress barShows the main progress bar (normally in the
            Help Line). This is normally issued through MEL when a length computation is
            about to occur.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - endProgress : ep               (bool)          [edit]
            Only valid for the main progress barHides the progress bar. No other flags can
            be used at the same time. This is normally issued through MEL in response to the
            -ic/isCancelled flag being set or if the progress value reaches its maximum.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isCancelled : ic               (bool)          [query]
            Returns true if the user has tried to cancel the operation. Returns false
            otherwise.
        
        - isInterruptable : ii           (bool)          [create,query,edit]
            Only valid for the main progress barReturns true if the isCancelled flag should
            respond to attempts to cancel the operation. Setting this to true will add a
            note in the help line display message to the user indicating that they can
            cancel the operation.
        
        - isMainProgressBar : imp        (bool)          [create,query,edit]
            Determines whether this progressBar is used to show the progress of all basic
            operations such as Open/Save file.The main progressBar behaves very differently,
            in that it only shows itself when there is an ongoing basic operation.Defaults
            to false, and only one progress bar will be recognized as the mainone.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (int)           [create,query,edit]
            The maximum or endingvalue of the progress indicator. If the progress value is
            greater than the -max/maxValue, the progress value will be set to the maximum.
            Default value is 100.
        
        - minValue : min                 (int)           [create,query,edit]
            The minimum or startingvalue of the progress indicator. If the progress value is
            less than the -min/minValue, the progress value will be set to the minimum.
            Default value is 0.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - progress : pr                  (int)           [create,query,edit]
            The amount of progress currently shown on the control. The value will always be
            between min and max. Default is equal to the minimum when the control is
            created.
        
        - status : st                    (unicode)       [create,query,edit]
            Only valid for the main progress barSets the contents of the helpLine control
            when the progressBar is showing. Use this instead of setting the helpLine
            directly because this will force a graphical refresh before returning.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (int)           [edit]
            Increments the -pr/progress value by the amount specified.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.progressBar`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'progressBar'
    
    
    __melui__ = 'progressBar'


class PromptDialog(PyUI):
    def getText(self, **kwargs):
        """
        The field text.                  
        
        
        Derived from mel command `maya.cmds.promptDialog`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The promptDialog command creates a modal dialog with a message to the user, a
        text field in which the user may enter a response, and a variable number of
        buttons to dismiss the dialog.  The dialog is dismissed when the user presses
        any button or chooses the close item from the window menu.  In the case where a
        button is pressed then the name of the button selected is returned.  If the
        dialog is dismissed via the close item then the string returned is specified by
        the -ds/dismissStringflag. The default behaviour when no arguments are specified
        is to create an empty single button dialog. To obtain the text entered by the
        user simply query the -tx/textflag.
        
        Flags:
        - backgroundColor : bgc          (float, float, float) [create]
            The background color of the dialog. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
            (Windows only flag)
        
        - button : b                     (unicode)       [create]
            Create a button with the given string as it's text.
        
        - cancelButton : cb              (unicode)       [create]
            The cancel button is activated by pressing the escape key. Note that this flag
            does not create a button, it simply indicates which button created via the
            -b/buttonflag shall respond to the escape key.
        
        - defaultButton : db             (unicode)       [create]
            The default button is activated by pressing the enter key. Note that this flag
            does not create a button, it simply indicates which button created via the
            -b/buttonflag shall respond to the enter key.
        
        - dismissString : ds             (unicode)       [create]
            The string returned when the user selects the 'Close' item from the Window
            Manager menu.  If this flag is not set then the string dismissis returned.
        
        - message : m                    (unicode)       [create]
            The message text appearing in the dialog.
        
        - messageAlign : ma              (unicode)       [create]
            Align the message left, center, or right.
        
        - parent : p                     (unicode)       [create]
            Specify the parent window for the dialog.  The dialog will be centered on this
            window and raise and lower with it's parent. By default, the dialog is not
            parented to a particular window and is simply centered on the screen.
        
        - scrollableField : sf           (bool)          [create]
            By default a single line text field is used in the dialog. Specify true for a
            multi-line scroll field.
        
        - style : st                     (unicode)       [create]
            Specify the type of input expected in the input field. Vaid input types are
            integerfloattext. If this flag is not specified, we assume the input type is
            text.
        
        - text : tx                      (unicode)       [create,query]
            The field text.
        
        - title : t                      (unicode)       [create]
            The dialog title.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.promptDialog`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'promptDialog'
    
    
    __melui__ = 'promptDialog'


class IntScrollBar(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes.  This command is not invoked when the value changes via the -v/value flag.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes by dragging the scroll bar's value marker.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getHorizontal(self, **kwargs):
        """
        Orientation of the scroll bar.  This flag is true by default, which corresponds to a horizontally oriented scroll bar.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getLargeStep(self, **kwargs):
        """
        Larger increment for the scroll bar, ie. the increment used when the press is between the arrow button and the thumb.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Upper limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Lower limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getStep(self, **kwargs):
        """
        Smaller increment for the scroll bar, ie. the increment used when the arrow buttons are pressed.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setLargeStep(self, val='True', **kwargs):
        """
        Larger increment for the scroll bar, ie. the increment used when the press is between the arrow button and the thumb.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Upper limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Lower limit of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Smaller increment for the scroll bar, ie. the increment used when the arrow buttons are pressed.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the scroll bar.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a scroll bar control that accepts only integer values and is bound by a
        minimum and maximum value.  The scroll bar displays a marker indicating the
        current value of the scroll bar relative to its minimum and maximum values.
        Click and drag the marker or on the scroll bar itself to change the current
        value.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the value changes.  This command is not invoked when the
            value changes via the -v/value flag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command executed when the value changes by dragging the scroll bar's value
            marker.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontal : hr                (bool)          [create,query]
            Orientation of the scroll bar.  This flag is true by default, which corresponds
            to a horizontally oriented scroll bar.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - largeStep : ls                 (int)           [create,query,edit]
            Larger increment for the scroll bar, ie. the increment used when the press is
            between the arrow button and the thumb.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (int)           [create,query,edit]
            Upper limit of the scroll bar.
        
        - minValue : min                 (int)           [create,query,edit]
            Lower limit of the scroll bar.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (int)           [create,query,edit]
            Smaller increment for the scroll bar, ie. the increment used when the arrow
            buttons are pressed.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (int)           [create,query,edit]
            Value of the scroll bar.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.intScrollBar`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'intScrollBar'
    
    
    __melui__ = 'intScrollBar'


class CheckBox(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getAlign(self, **kwargs):
        """
        This flag is obsolete and should no longer be used. The check box label will always be left-aligned.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getChangeCommand(self, **kwargs):
        """
        Command executed when the check box's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the check box from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the check box.  By default, this flag is set to true and the check box value may be changed by clicking on it.  If false then the check box is 'read only' and can not be clicked on. The value of the check box can always be changed with the -v/valueflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The label text. The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getOffCommand(self, **kwargs):
        """
        Command executed when the check box is turned off.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getOnCommand(self, **kwargs):
        """
        Command executed when the check box is turned on.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getRecomputeSize(self, **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getValue(self, **kwargs):
        """
        State of the check box.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        This flag is obsolete and should no longer be used. The check box label will always be left-aligned.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setChangeCommand(self, val='True', **kwargs):
        """
        Command executed when the check box's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the check box from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the check box.  By default, this flag is set to true and the check box value may be changed by clicking on it.  If false then the check box is 'read only' and can not be clicked on. The value of the check box can always be changed with the -v/valueflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The label text. The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setOffCommand(self, val='True', **kwargs):
        """
        Command executed when the check box is turned off.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setOnCommand(self, val='True', **kwargs):
        """
        Command executed when the check box is turned on.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setRecomputeSize(self, val='True', **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        State of the check box.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a check box.  A check box is a simple control containing a
        text label and a state of either on or off.  Commands can be attached to any or
        all of the following events:  when the check box is turned on, turned off, or
        simply when it's state is changed.
        
        Flags:
        - align : al                     (unicode)       [create,query,edit]
            This flag is obsolete and should no longer be used. The check box label will
            always be left-aligned.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,query,edit]
            Command executed when the check box's state is changed. Note that this flag
            should not be used in conjunction with onCommand and offCommand. That is, one
            should either use changeCommand and test the state of the check box from inside
            the callback, or use onCommand and offCommand as separate callbacks.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the check box.  By default, this flag is set to true and the
            check box value may be changed by clicking on it.  If false then the check box
            is 'read only' and can not be clicked on. The value of the check box can always
            be changed with the -v/valueflag regardless of the state of the
            -ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The label text. The default label is the name of the control.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - offCommand : ofc               (script)        [create,query,edit]
            Command executed when the check box is turned off.
        
        - onCommand : onc                (script)        [create,query,edit]
            Command executed when the check box is turned on.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - recomputeSize : rs             (bool)          [create,query,edit]
            If true then the control will recompute it's size to just fit the size of the
            label.  If false then the control size will remain fixed as you change the size
            of the label.  The default value of this flag is true.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (bool)          [create,query,edit]
            State of the check box.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.checkBox`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'checkBox'
    
    
    __melui__ = 'checkBox'


class SymbolButton(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Command executed when the symbol button is pressed.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getImage(self, **kwargs):
        """
        Image for the button.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        Command executed when the symbol button is pressed.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Image for the button.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a symbol button.  A symbol button behaves like a regular
        button, the only difference is a symbol button displays an image rather that a
        text label.  A command may be attached to the button which will be executed when
        the button is pressed.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - command : c                    (script)        [create,query,edit]
            Command executed when the symbol button is pressed.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - image : i                      (unicode)       [create,query,edit]
            Image for the button.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.symbolButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'symbolButton'
    
    
    __melui__ = 'symbolButton'


class Image(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getImage(self, **kwargs):
        """
        Sets the image given the file name.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Sets the image given the file name.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a static image for non-xpm files. Any image file format
        supported by the file texture node is supported by this command.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - image : i                      (unicode)       [create,query,edit]
            Sets the image given the file name.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.image`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'image'
    
    
    __melui__ = 'image'


class MessageLine(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a message line where tool feedback is shown.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.messageLine`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'messageLine'
    
    
    __melui__ = 'messageLine'


class NodeIconButton(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getAlign(self, **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Command executed when the control is pressed. The command should return a string which will be used to facilitate node drag and drop.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getDisabledImage(self, **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getFlipX(self, **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getFlipY(self, **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getImage(self, **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getImage1(self, **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getImage2(self, **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getImage3(self, **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getLabelOffset(self, **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getMarginHeight(self, **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getMarginWidth(self, **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getOverlayLabelBackColor(self, **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getOverlayLabelColor(self, **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getRotation(self, **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getStyle(self, **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getUseAlpha(self, **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        Command executed when the control is pressed. The command should return a string which will be used to facilitate node drag and drop.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setDisabledImage(self, val='True', **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setFlipX(self, val='True', **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setFlipY(self, val='True', **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setImage1(self, val='True', **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setImage2(self, val='True', **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setImage3(self, val='True', **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setLabelOffset(self, val='True', **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setMarginHeight(self, val='True', **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setMarginWidth(self, val='True', **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setOverlayLabelBackColor(self, val='True', **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setOverlayLabelColor(self, val='True', **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setRotation(self, val='True', **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setUseAlpha(self, val='True', **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This control supports up to 3 icon images and 4 different display styles.  The
        icon image displayed is the one that best fits the current size of the control
        given its current style. This command creates a button that can be displayed
        with different icons, with or without a text label. If the button is drag and
        dropped onto other controls (e.g., HyperShade), the command will be executed and
        the return string will be used as the name of a dropped node.
        
        Flags:
        - align : al                     (unicode)       [create,query,edit]
            The label alignment.  Alignment values are left, right, and center. By default,
            the label is aligned center. Currently only available when -st/style is set to
            iconAndTextCentered.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - command : c                    (script)        [create,query,edit]
            Command executed when the control is pressed. The command should return a string
            which will be used to facilitate node drag and drop.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disabledImage : di             (unicode)       [create,query,edit]
            Image used when the button is disabled. Image size must be the same as the image
            specified with the i/imageflag. This is a Windows only flag.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - flipX : fx                     (bool)          [create,query,edit]
            Is the image flipped horizontally?
        
        - flipY : fy                     (bool)          [create,query,edit]
            Is the image flipped vertically?
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - image : i                      (unicode)       [create,query,edit]
            If you are not providing images with different sizes then you may use this flag
            for the control's image. If the iconOnlystyle is set, the icon will be scaled to
            the size of the control.
        
        - image1 : i1                    (unicode)       [create,query,edit]
            First of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image2 : i2                    (unicode)       [create,query,edit]
            Second of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image3 : i3                    (unicode)       [create,query,edit]
            Third of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            A short string, up to 6 characters, representing a label that will be displayed
            on top of the image.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The text that appears in the control.
        
        - labelOffset : lo               (int)           [create,query,edit]
            The label offset. Default is 0. Currently only available when -st/style is set
            to iconAndTextCentered.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - marginHeight : mh              (int)           [create,query,edit]
            The number of pixels above and below the control content. The default value is 1
            pixel.
        
        - marginWidth : mw               (int)           [create,query,edit]
            The number of pixels on either side of the control content. The default value is
            1 pixel.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - overlayLabelBackColor : olb    (float, float, float, float) [create,query,edit]
            The RGBA color of the shadow behind the label defined by imageOverlayLabel.
            Default is 50% transparent black: 0 0 0 .5
        
        - overlayLabelColor : olc        (float, float, float) [create,query,edit]
            The RGB color of the label defined by imageOverlayLabel. Default is a light
            grey: .8 .8 .8
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rotation : rot                 (float)         [create,query,edit]
            The rotation value of the image in radians.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            The draw style of the control.  Valid styles are iconOnly, textOnly,
            iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note:
            iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set,
            the icon will be scaled to the size of the control.
        
        - useAlpha : ua                  (bool)          [create,query,edit]
            Is the image using alpha channel?
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this control feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.nodeIconButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'nodeIconButton'
    
    
    __melui__ = 'nodeIconButton'


class HyperGraph(PyUI):
    def addBookmark(self, val='True', **kwargs):
        """
        Create a bookmark for the current hypergraph view.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def addDependGraph(self, val='True', **kwargs):
        """
        Add a dependency graph starting at the named node to the view                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def addDependNode(self, val='True', **kwargs):
        """
        Add a dependency node to the dependency graph view                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def attributeEditor(self, val='True', **kwargs):
        """
        Launches attribute editor on selected node.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def backward(self, val='True', **kwargs):
        """
        Navigate backward one step.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def clear(self, val='True', **kwargs):
        """
        Clears the current hypergraph view and deletes the graph UI. (see also -rebuild flag)                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def collapseContainer(self, val='True', **kwargs):
        """
        Collapses containers selected in DG graph.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def connectionDrawStyle(self, val='True', **kwargs):
        """
        Specify how connections between nodes should be drawn. Valid values are center(draws connection lines from the center of one node to the center of the other) and side(draws connection lines from the right side of the source node to the left side of the destination node). The default is center. This flag does not apply to Hypershade graphs, which are always drawn with the sideconnection draw style.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def debug(self, val='True', **kwargs):
        """
        Run a debug method on the graph                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def deleteBookmark(self, val='True', **kwargs):
        """
        Delete the bookmark with the corresponding node name.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def dependGraph(self, val='True', **kwargs):
        """
        Displays dependency graph iterated from specified node.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def dependNode(self, val='True', **kwargs):
        """
        Displays dependency node in view.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def directoryPressCommand(self, val='True', **kwargs):
        """
        Specify a command to run when a directory is pressed.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def down(self, val='True', **kwargs):
        """
        Navigate down to the dependency graph containing the current selection. Shows upstream and downstream connections.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def downstream(self, val='True', **kwargs):
        """
        Show downstream dependency graph of selected node(s).                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def dragAndDropBehaviorCommand(self, val='True', **kwargs):
        """
        Mel proc called when a drag and drop onto a hyperGraph node has occurred. Proc signature is procName (string $editor, string $sourceNode, string $destinationNode).                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def edgeDblClickCommand(self, val='True', **kwargs):
        """
        Mel proc called when an edge is double clicked.  Proc signature is procName (string $editor, string $edge).                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def edgeDimmedDblClickCommand(self, val='True', **kwargs):
        """
        Mel proc called when a dimmed edge is double clicked.  Proc signature is procName (string $editor, string $edge).                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def edgeDropCommand(self, val='True', **kwargs):
        """
        Command to execute when an edge drop occurs.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def edgePressCommand(self, val='True', **kwargs):
        """
        Command to execute when an edge press occurs.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def edgeReleaseCommand(self, val='True', **kwargs):
        """
        Command to execute when an edge release occurs.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def enableAutomaticLayout(self, val='True', **kwargs):
        """
        Rebuild the graph if a node is added or removed from the graph via drag and drop or dg messages. Default is true.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def expandContainer(self, val='True', **kwargs):
        """
        Expands containers selected in DG graph.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def filterDetail(self, val='True', **kwargs):
        """
        This flag is obsolete. Use the showConstraints, showExpressions, showDeformer, showInvisible, showShapes and showUnderworld flags instead.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def focusCommand(self, val='True', **kwargs):
        """
        Mel proc to be run when the mouse is clicked in the hyper graph. Primarily of use in setting the window focus.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def fold(self, val='True', **kwargs):
        """
        Folds (Collapses) selected object.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def forceRefresh(self, val='True', **kwargs):
        """
        Forces the hypergraph to refresh (redraw) its contents.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def forward(self, val='True', **kwargs):
        """
        Navigate forward one step.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def frame(self, val='True', **kwargs):
        """
        Frames the selected objects                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def frameBranch(self, val='True', **kwargs):
        """
        Frames the the branch from the selected node on downward.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def frameGraph(self, val='True', **kwargs):
        """
        Frames the entire graph.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def frameGraphNoRebuild(self, val='True', **kwargs):
        """
        Specify that on zoom out the graph should not rebuild; for efficiency.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def frameHierarchy(self, val='True', **kwargs):
        """
        Frames the hierarchy that contains the selected node.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getAnimateTransition(self, **kwargs):
        """
        Turns animate transitions off and on.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getBookmarkName(self, **kwargs):
        """
        Returns the bookmark name for the most recently created bookmark.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getBreakConnectionCommand(self, **kwargs):
        """
        Specify the command to call when a connection is broken.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getCurrentEdge(self, **kwargs):
        """
        Return the current edge name.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getCurrentNode(self, **kwargs):
        """
        Return the current node name.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getDropNode(self, **kwargs):
        """
        Returns the name of the source node in a drag and drop connection, when called during processing of a drop.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getDropTargetNode(self, **kwargs):
        """
        Returns the name of the destination node in a drag and drop connection, when called during processing of a drop.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getFeedbackGadget(self, **kwargs):
        """
        Returns the name of the current gadget.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getFeedbackNode(self, **kwargs):
        """
        Returns the name of the current feedback or highlight node.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getFreeform(self, **kwargs):
        """
        Enable freeform layout mode.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getFromAttr(self, **kwargs):
        """
        Returns the name of the source attribute in a drag and drop connection, when called during processing of a drop.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getFromNode(self, **kwargs):
        """
        Returns the name of the source node in a drag and drop connection, when called during processing of a drop.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getGetNodeList(self, **kwargs):
        """
        Returns a string array that represents a list of all the nodes in the graph.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getGetNodePosition(self, **kwargs):
        """
        Returns the position of a specified node in x,y graph coords. This flag and its argument must be passed to the command before the -q flag (see examples).       In query mode, this flag can accept a value.
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getGraphLayoutStyle(self, **kwargs):
        """
        This flag is obsolete.  The only supported graph layout style is hierarchicalLayout. Use of any other style will trigger a warning.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getGraphType(self, **kwargs):
        """
        Returns the type name of the current graph in the view (either DAG or DG).                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getHeatMapDisplay(self, **kwargs):
        """
        Specify whether the heat map should be shown or not.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getIconSize(self, **kwargs):
        """
        Set or query the icon size for this hyper graph editor. The currently allowed icon sizes are smallIcons, mediumIcons, largeIconsand superIcons.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getImage(self, **kwargs):
        """
        Specify background image to be loaded from the project image directory.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getImageEnabled(self, **kwargs):
        """
        Enable display of a loaded background image (Freeform DAG view or DG view)                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getImageForContainer(self, **kwargs):
        """
        Specify that the following flags work on selected containers instead of the whole image: -imageScale,-imagePosition, fitImageToWidth, -fitImageToHeight, -image                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getImagePosition(self, **kwargs):
        """
        Position of the background image.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getImageScale(self, **kwargs):
        """
        Uniform scale of the background image.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getIsHotkeyTarget(self, **kwargs):
        """
        For internal use.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getMergeConnections(self, **kwargs):
        """
        Merge groups of connections into 'fat' connections.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getOpaqueContainers(self, **kwargs):
        """
        Sets expanded container background opacity.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getOrientation(self, **kwargs):
        """
        Selects orientation style of graph: horiz|vert
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getRange(self, **kwargs):
        """
        Limits the display of nodes to only those within the range. There are two float values expected, the first the lower threshold of the range and the second the upper threshold of the range. The values are absolute timing values, not percentages.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowConnectionFromSelected(self, **kwargs):
        """
        Show the connects (constraints, expresions, and deformers - see showConstraints for example) leaving from selected nodes. This can be combined with showConnectionToSelected to show both arrive and leaving connects. If both flags are false then all the connections will be shown.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowConnectionToSelected(self, **kwargs):
        """
        Show the connects (constraints, expresions, and deformers - see showConstraints for example) arriving at selected nodes. This can be combined with showConnectionFromSelected to show both arrive and leaving connects. If both flags are false then all the connections will be shown.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowConstraints(self, **kwargs):
        """
        Show constraint relationships in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowDeformers(self, **kwargs):
        """
        Show deformer or geometry filter relationships in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowExpressions(self, **kwargs):
        """
        Show expression relationships in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowInvisible(self, **kwargs):
        """
        Show invisible nodes in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowRelationships(self, **kwargs):
        """
        Show relationship (message) connections.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowShapes(self, **kwargs):
        """
        Show shape nodes in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getShowUnderworld(self, **kwargs):
        """
        Show underworld graphs in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getToAttr(self, **kwargs):
        """
        Returns the name of the destination attribute in a drag and drop connection, when called during processing of a drop.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getToNode(self, **kwargs):
        """
        Returns the name of the destination node in a drag and drop connection, when called during processing of a drop.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getTransitionFrames(self, **kwargs):
        """
        Specify te number of transition frames for animate transitions.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getUpdateNodeAdded(self, **kwargs):
        """
        Update graph when a new node is added to the database                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getUpdateSelection(self, **kwargs):
        """
        Update selection state in the graph when the selection state of database changes.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getUseFeedbackList(self, **kwargs):
        """
        Use feedback or highlight list as the target selection when processing other hypergraph command-line options.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def getViewOption(self, **kwargs):
        """
        Set or query the view option for this hyper graph editor. The currently allowed views are asIconsand asList.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def graphDescription(self, val='True', **kwargs):
        """
        When used, return a description of the current graph.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def initializeScript(self, val='True', **kwargs):
        """
        Script to call when the graph is initialized.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def layout(self, val='True', **kwargs):
        """
        Perform an automatic layout on the graph.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def layoutSelected(self, val='True', **kwargs):
        """
        This flag is obsolete.  The only supported graph layout style is hierarchicalLayout. Use of any other style will trigger a warning.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def limitGraphTraversal(self, val='True', **kwargs):
        """
        Limit the graph traversal to a certain number of levels.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def look(self, val='True', **kwargs):
        """
        Look at a coordinate in the graph view                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def navigateHome(self, val='True', **kwargs):
        """
        Navigate to the home (DAG) view.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def navup(self, val='True', **kwargs):
        """
        Navigate up to the dependency graph containing the current selection. Shows upstream and downstream connections.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def newInputConnection(self, val='True', **kwargs):
        """
        Specify a new connection, input side                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def newOutputConnection(self, val='True', **kwargs):
        """
        Specify a new connection, output side                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def nextView(self, val='True', **kwargs):
        """
        Changes the view to the next DAG view.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def nodeConnectCommand(self, val='True', **kwargs):
        """
        Command to call when a node is connected.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def nodeDblClickCommand(self, val='True', **kwargs):
        """
        Command to call when a node is double-clicked.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def nodeDropCommand(self, val='True', **kwargs):
        """
        Set the command to be called when a node is dropped in the hypergraph window.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def nodeMenuCommand(self, val='True', **kwargs):
        """
        Command to call when a node menu is activated.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def nodePressCommand(self, val='True', **kwargs):
        """
        Set the command to be called when the user presses a mouse button while the cursor is over a node in the hypergraph window.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def nodeReleaseCommand(self, val='True', **kwargs):
        """
        Set the command to be called when the user releases a mouse button while the cursor is over a node in the hypergraph window.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def panView(self, val='True', **kwargs):
        """
        Pan the view to a new center.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def popupMenuScript(self, val='True', **kwargs):
        """
        Set the script to be called to register the popup menu with the control for this hypergraph. The script will be called with a string argument which gives the name of the hypergraph whose control the popup menu should be parented to.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def previousView(self, val='True', **kwargs):
        """
        Changes the view back to the previous DAG view.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def rebuild(self, val='True', **kwargs):
        """
        Rebuilds graph                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def removeNode(self, val='True', **kwargs):
        """
        Removes the node identified by string from the graph.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def resetFreeform(self, val='True', **kwargs):
        """
        Resets freeform position on all nodes.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def restoreBookmark(self, val='True', **kwargs):
        """
        Restore the view corresponding to the bookmark.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def scrollUpDownNoZoom(self, val='True', **kwargs):
        """
        Specify if we want to be in the scroll along y only with no free zooming mode. By default, hyper graph editor allows user to pan left and right.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setAnimateTransition(self, val='True', **kwargs):
        """
        Turns animate transitions off and on.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setBreakConnectionCommand(self, val='True', **kwargs):
        """
        Specify the command to call when a connection is broken.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setCurrentEdge(self, val='True', **kwargs):
        """
        Return the current edge name.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setCurrentNode(self, val='True', **kwargs):
        """
        Return the current node name.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setFreeform(self, val='True', **kwargs):
        """
        Enable freeform layout mode.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setGraphLayoutStyle(self, val='True', **kwargs):
        """
        This flag is obsolete.  The only supported graph layout style is hierarchicalLayout. Use of any other style will trigger a warning.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setHeatMapDisplay(self, val='True', **kwargs):
        """
        Specify whether the heat map should be shown or not.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setIconSize(self, val='True', **kwargs):
        """
        Set or query the icon size for this hyper graph editor. The currently allowed icon sizes are smallIcons, mediumIcons, largeIconsand superIcons.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Specify background image to be loaded from the project image directory.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setImageEnabled(self, val='True', **kwargs):
        """
        Enable display of a loaded background image (Freeform DAG view or DG view)                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setImageForContainer(self, val='True', **kwargs):
        """
        Specify that the following flags work on selected containers instead of the whole image: -imageScale,-imagePosition, fitImageToWidth, -fitImageToHeight, -image                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setImagePosition(self, val='True', **kwargs):
        """
        Position of the background image.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setImageScale(self, val='True', **kwargs):
        """
        Uniform scale of the background image.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setMergeConnections(self, val='True', **kwargs):
        """
        Merge groups of connections into 'fat' connections.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setNodePosition(self, val='True', **kwargs):
        """
        Sets the node identified by string to the (x,y) position in the window specified by the two floats. If the node is not in the graph than it will be added to the graph and then moved to the new position.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setOpaqueContainers(self, val='True', **kwargs):
        """
        Sets expanded container background opacity.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setOrientation(self, val='True', **kwargs):
        """
        Selects orientation style of graph: horiz|vert
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setRange(self, val='True', **kwargs):
        """
        Limits the display of nodes to only those within the range. There are two float values expected, the first the lower threshold of the range and the second the upper threshold of the range. The values are absolute timing values, not percentages.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowConnectionFromSelected(self, val='True', **kwargs):
        """
        Show the connects (constraints, expresions, and deformers - see showConstraints for example) leaving from selected nodes. This can be combined with showConnectionToSelected to show both arrive and leaving connects. If both flags are false then all the connections will be shown.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowConnectionToSelected(self, val='True', **kwargs):
        """
        Show the connects (constraints, expresions, and deformers - see showConstraints for example) arriving at selected nodes. This can be combined with showConnectionFromSelected to show both arrive and leaving connects. If both flags are false then all the connections will be shown.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowConstraints(self, val='True', **kwargs):
        """
        Show constraint relationships in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowDeformers(self, val='True', **kwargs):
        """
        Show deformer or geometry filter relationships in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowExpressions(self, val='True', **kwargs):
        """
        Show expression relationships in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowInvisible(self, val='True', **kwargs):
        """
        Show invisible nodes in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowRelationships(self, val='True', **kwargs):
        """
        Show relationship (message) connections.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowShapes(self, val='True', **kwargs):
        """
        Show shape nodes in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setShowUnderworld(self, val='True', **kwargs):
        """
        Show underworld graphs in the DAG.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setTransitionFrames(self, val='True', **kwargs):
        """
        Specify te number of transition frames for animate transitions.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setUpdateNodeAdded(self, val='True', **kwargs):
        """
        Update graph when a new node is added to the database                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setUpdateSelection(self, val='True', **kwargs):
        """
        Update selection state in the graph when the selection state of database changes.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setUseFeedbackList(self, val='True', **kwargs):
        """
        Use feedback or highlight list as the target selection when processing other hypergraph command-line options.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def setViewOption(self, val='True', **kwargs):
        """
        Set or query the view option for this hyper graph editor. The currently allowed views are asIconsand asList.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def showCachedConnections(self, val='True', **kwargs):
        """
        Specify whether cached connections should be shown.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def showConstraintLabels(self, val='True', **kwargs):
        """
        Specify whether constraint labels should be shown.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def unfold(self, val='True', **kwargs):
        """
        Unfolds (expands) selected object.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def unfoldAll(self, val='True', **kwargs):
        """
        Unfolds everything under selected object.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def unfoldAllShapes(self, val='True', **kwargs):
        """
        Unfolds all shapes.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def unfoldHidden(self, val='True', **kwargs):
        """
        Unfolds all hidden objects.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def upstream(self, val='True', **kwargs):
        """
        Show upstream dependency graph of selected node(s).                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def useDrawOverrideColor(self, val='True', **kwargs):
        """
        Specify whether or not to use draw override coloring.                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def visibility(self, val='True', **kwargs):
        """
        Set the visible state of the selected node(s).                  
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    def zoom(self, val='True', **kwargs):
        """
        Specify the zoom factor for animating transitions                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The following is an overview of the basic features of the hypergraph. A more
        detailed description is given in the user manuals. The hypergraph provides the
        user with the ability to view and edit the maya scene graph.  The hypergraph
        supports two types of graphs: the DAG or scene hierarchy and the dependency
        graph. The default view of the hypergraph editor is the DAG view. The user can
        show the dependency graph for a collection of nodes by first selecting the nodes
        and navigating to the dependency graph using one of the graph options.  The user
        can save any view by setting a bookmark to that view.  The user can also show
        previous views using the view options provided. The hypergraph supports a simple
        editing mechanism for editing hierarchy in the DAG view and connections in
        dependency graph view. In the DAG  view, the user can reparent or reorder nodes
        in the graph using drag-and-drop. In the dependency graph view, the user can
        select connections and delete them or make new connections by dragging and
        dropping nodes or existing connections. The hypergraph supports two layout modes
        in the DAG view: automatic and freeform.  In automatic mode, the graph nodes are
        automatically positioned according to the layout preferences.  In freeform mode,
        the user can position nodes manually.  The node position is saved in the scene.
        A background image can be placed behind DG or DAG in freeform mode. This can be
        used as a template for positioning nodes in a user-defined layout. Nodes in the
        DAG view can be expanded or collapsed.  The state is saved in the scene.  The
        performance of the graph drawing will increase as hierarchies are collapsed. In
        addition to hierachy relationships, the hypergraph can show expression,
        constraint and deformation relationships in the DAG. These can be
        enabled/disabled through the options provided.  There are also additional
        filters for showing shape nodes and invisible nodes.  The amount of detail show
        may affect the speed of the display of the graph. Most of the UI features of the
        hypergraph are addressable through the hypergraph command-line interface.  The
        available command-line options are described in the next section.
        
        Flags:
        - addBookmark : abk              (bool)          [create,edit]
            Create a bookmark for the current hypergraph view.
        
        - addDependGraph : adg           (PyNode)        [create,edit]
            Add a dependency graph starting at the named node to the view
        
        - addDependNode : adn            (PyNode)        [create,edit]
            Add a dependency node to the dependency graph view
        
        - animateTransition : atr        (bool)          [create,query,edit]
            Turns animate transitions off and on.
        
        - attributeEditor : ae           (unicode)       [create,edit]
            Launches attribute editor on selected node.
        
        - backward : bak                 (bool)          [create,edit]
            Navigate backward one step.
        
        - bookmarkName : bn              (bool)          [query]
            Returns the bookmark name for the most recently created bookmark.
        
        - breakConnectionCommand : bco   (unicode)       [create,query,edit]
            Specify the command to call when a connection is broken.
        
        - clear : clr                    (bool)          [create,edit]
            Clears the current hypergraph view and deletes the graph UI. (see also -rebuild
            flag)
        
        - collapseContainer : cc         (bool)          [create,edit]
            Collapses containers selected in DG graph.
        
        - connectionDrawStyle : cds      (unicode)       [create,edit]
            Specify how connections between nodes should be drawn. Valid values are
            center(draws connection lines from the center of one node to the center of the
            other) and side(draws connection lines from the right side of the source node to
            the left side of the destination node). The default is center. This flag does
            not apply to Hypershade graphs, which are always drawn with the sideconnection
            draw style.
        
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - currentEdge : ced              (unicode)       [query,edit]
            Return the current edge name.
        
        - currentNode : cno              (unicode)       [query,edit]
            Return the current node name.
        
        - debug : deb                    (unicode)       [create,edit]
            Run a debug method on the graph
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteBookmark : dbk           (unicode)       [create,edit]
            Delete the bookmark with the corresponding node name.
        
        - dependGraph : dg               (bool)          [create,edit]
            Displays dependency graph iterated from specified node.
        
        - dependNode : dn                (unicode)       [create,edit]
            Displays dependency node in view.
        
        - directoryPressCommand : dp     (unicode)       [create,edit]
            Specify a command to run when a directory is pressed.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - down : do                      (bool)          [create,edit]
            Navigate down to the dependency graph containing the current selection. Shows
            upstream and downstream connections.
        
        - downstream : ds                (bool)          [create,edit]
            Show downstream dependency graph of selected node(s).
        
        - dragAndDropBehaviorCommand : ddc (unicode)       [create,edit]
            Mel proc called when a drag and drop onto a hyperGraph node has occurred. Proc
            signature is procName (string $editor, string $sourceNode, string
            $destinationNode).
        
        - dropNode : dr                  (unicode)       [query]
            Returns the name of the source node in a drag and drop connection, when called
            during processing of a drop.
        
        - dropTargetNode : drt           (unicode)       [query]
            Returns the name of the destination node in a drag and drop connection, when
            called during processing of a drop.
        
        - edgeDblClickCommand : edc      (unicode)       [create,edit]
            Mel proc called when an edge is double clicked.  Proc signature is procName
            (string $editor, string $edge).
        
        - edgeDimmedDblClickCommand : edd (unicode)       [create,edit]
            Mel proc called when a dimmed edge is double clicked.  Proc signature is
            procName (string $editor, string $edge).
        
        - edgeDropCommand : edr          (unicode)       [create,edit]
            Command to execute when an edge drop occurs.
        
        - edgePressCommand : ep          (unicode)       [create,edit]
            Command to execute when an edge press occurs.
        
        - edgeReleaseCommand : er        (unicode)       [create,edit]
            Command to execute when an edge release occurs.
        
        - enableAutomaticLayout : eal    (bool)          [create,edit]
            Rebuild the graph if a node is added or removed from the graph via drag and drop
            or dg messages. Default is true.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - expandContainer : ec           (bool)          [create,edit]
            Expands containers selected in DG graph.
        
        - feedbackGadget : fbg           (unicode)       [query]
            Returns the name of the current gadget.
        
        - feedbackNode : fbn             (unicode)       [query]
            Returns the name of the current feedback or highlight node.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - filterDetail : fd              (unicode, bool) [create,edit]
            This flag is obsolete. Use the showConstraints, showExpressions, showDeformer,
            showInvisible, showShapes and showUnderworld flags instead.
        
        - fitImageToHeight : fih         (bool)          [create]
            Changes position and scale of background image, so its height fits current
            editor view.
        
        - fitImageToWidth : fiw          (bool)          [create]
            Changes position and scale of background image, so its width fits current editor
            view.
        
        - focusCommand : fc              (unicode)       [create,edit]
            Mel proc to be run when the mouse is clicked in the hyper graph. Primarily of
            use in setting the window focus.
        
        - fold : fo                      (bool)          [create,edit]
            Folds (Collapses) selected object.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - forceRefresh : frf             (bool)          [create,edit]
            Forces the hypergraph to refresh (redraw) its contents.
        
        - forward : fow                  (bool)          [create,edit]
            Navigate forward one step.
        
        - frame : fr                     (bool)          [create,edit]
            Frames the selected objects
        
        - frameBranch : frb              (bool)          [create,edit]
            Frames the the branch from the selected node on downward.
        
        - frameGraph : fg                (bool)          [create,edit]
            Frames the entire graph.
        
        - frameGraphNoRebuild : fgn      (bool)          [create,edit]
            Specify that on zoom out the graph should not rebuild; for efficiency.
        
        - frameHierarchy : frh           (bool)          [create,edit]
            Frames the hierarchy that contains the selected node.
        
        - freeform : fre                 (bool)          [create,query,edit]
            Enable freeform layout mode.
        
        - fromAttr : fat                 (unicode)       [query]
            Returns the name of the source attribute in a drag and drop connection, when
            called during processing of a drop.
        
        - fromNode : frn                 (unicode)       [query]
            Returns the name of the source node in a drag and drop connection, when called
            during processing of a drop.
        
        - getNodeList : gnl              (bool)          [query]
            Returns a string array that represents a list of all the nodes in the graph.
        
        - getNodePosition : gnp          (unicode)       [query]
            Returns the position of a specified node in x,y graph coords. This flag and its
            argument must be passed to the command before the -q flag (see examples).
            In query mode, this flag can accept a value.
        
        - graphDescription : gd          (bool)          [create,edit]
            When used, return a description of the current graph.
        
        - graphLayoutStyle : gls         (unicode)       [create,query,edit]
            This flag is obsolete.  The only supported graph layout style is
            hierarchicalLayout. Use of any other style will trigger a warning.
        
        - graphType : gt                 (unicode)       [query]
            Returns the type name of the current graph in the view (either DAG or DG).
        
        - heatMapDisplay : hmd           (bool)          [query,edit]
            Specify whether the heat map should be shown or not.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - iconSize : ics                 (unicode)       [create,query,edit]
            Set or query the icon size for this hyper graph editor. The currently allowed
            icon sizes are smallIcons, mediumIcons, largeIconsand superIcons.
        
        - image : img                    (unicode)       [create,query,edit]
            Specify background image to be loaded from the project image directory.
        
        - imageEnabled : ime             (bool)          [create,query,edit]
            Enable display of a loaded background image (Freeform DAG view or DG view)
        
        - imageForContainer : ifc        (bool)          [create,query,edit]
            Specify that the following flags work on selected containers instead of the
            whole image: -imageScale,-imagePosition, fitImageToWidth, -fitImageToHeight,
            -image
        
        - imagePosition : imp            (float, float)  [create,query,edit]
            Position of the background image.
        
        - imageScale : ims               (float)         [create,query,edit]
            Uniform scale of the background image.
        
        - initializeScript : ini         (unicode)       [create,edit]
            Script to call when the graph is initialized.
        
        - isHotkeyTarget : iht           (bool)          [query]
            For internal use.
        
        - layout : lay                   (bool)          [create,edit]
            Perform an automatic layout on the graph.
        
        - layoutSelected : lsl           (unicode)       [create,edit]
            This flag is obsolete.  The only supported graph layout style is
            hierarchicalLayout. Use of any other style will trigger a warning.
        
        - layoutSubtree : lsb            (bool)          []
        
        - limitGraphTraversal : lgt      (int)           [create,edit]
            Limit the graph traversal to a certain number of levels.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - look : loo                     (float, float)  [create,edit]
            Look at a coordinate in the graph view
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - mergeConnections : mc          (bool)          [create,query,edit]
            Merge groups of connections into 'fat' connections.
        
        - navigateHome : hom             (bool)          [create,edit]
            Navigate to the home (DAG) view.
        
        - navup : nu                     (bool)          [create,edit]
            Navigate up to the dependency graph containing the current selection. Shows
            upstream and downstream connections.
        
        - newInputConnection : nin       (unicode)       [create,edit]
            Specify a new connection, input side
        
        - newOutputConnection : nou      (unicode)       [create,edit]
            Specify a new connection, output side
        
        - nextView : nvw                 (bool)          [create,edit]
            Changes the view to the next DAG view.
        
        - nodeConnectCommand : nco       (unicode)       [create,edit]
            Command to call when a node is connected.
        
        - nodeDblClickCommand : ndc      (unicode)       [create,edit]
            Command to call when a node is double-clicked.
        
        - nodeDropCommand : ndr          (unicode)       [create,edit]
            Set the command to be called when a node is dropped in the hypergraph window.
        
        - nodeMenuCommand : nm           (unicode)       [create,edit]
            Command to call when a node menu is activated.
        
        - nodePressCommand : np          (unicode)       [create,edit]
            Set the command to be called when the user presses a mouse button while the
            cursor is over a node in the hypergraph window.
        
        - nodeReleaseCommand : nr        (unicode)       [create,edit]
            Set the command to be called when the user releases a mouse button while the
            cursor is over a node in the hypergraph window.
        
        - opaqueContainers : opc         (bool)          [query,edit]
            Sets expanded container background opacity.
        
        - orientation : orientation      (unicode)       [create,query,edit]
            Selects orientation style of graph: horiz|vert
        
        - panView : pan                  (float, float)  [create,edit]
            Pan the view to a new center.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - popupMenuScript : pms          (unicode)       [create,edit]
            Set the script to be called to register the popup menu with the control for this
            hypergraph. The script will be called with a string argument which gives the
            name of the hypergraph whose control the popup menu should be parented to.
        
        - previousView : pvw             (bool)          [create,edit]
            Changes the view back to the previous DAG view.
        
        - range : rg                     (float, float)  [create,query,edit]
            Limits the display of nodes to only those within the range. There are two float
            values expected, the first the lower threshold of the range and the second the
            upper threshold of the range. The values are absolute timing values, not
            percentages.
        
        - rebuild : rb                   (bool)          [create,edit]
            Rebuilds graph
        
        - removeNode : rmn               (unicode)       [create,edit]
            Removes the node identified by string from the graph.
        
        - rename : rn                    (bool)          [create,edit]
            Pops up text field over selected object for renaming
        
        - resetFreeform : rf             (bool)          [create,edit]
            Resets freeform position on all nodes.
        
        - restoreBookmark : rbk          (unicode)       [create,edit]
            Restore the view corresponding to the bookmark.
        
        - scrollUpDownNoZoom : snz       (bool)          [create,edit]
            Specify if we want to be in the scroll along y only with no free zooming mode.
            By default, hyper graph editor allows user to pan left and right.
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - setNodePosition : snp          (unicode, float, float) [create,edit]
            Sets the node identified by string to the (x,y) position in the window specified
            by the two floats. If the node is not in the graph than it will be added to the
            graph and then moved to the new position.
        
        - showCachedConnections : scc    (bool)          [create,edit]
            Specify whether cached connections should be shown.
        
        - showConnectionFromSelected : scf (bool)          [create,query,edit]
            Show the connects (constraints, expresions, and deformers - see showConstraints
            for example) leaving from selected nodes. This can be combined with
            showConnectionToSelected to show both arrive and leaving connects. If both flags
            are false then all the connections will be shown.
        
        - showConnectionToSelected : sct (bool)          [create,query,edit]
            Show the connects (constraints, expresions, and deformers - see showConstraints
            for example) arriving at selected nodes. This can be combined with
            showConnectionFromSelected to show both arrive and leaving connects. If both
            flags are false then all the connections will be shown.
        
        - showConstraintLabels : scl     (bool)          [create,edit]
            Specify whether constraint labels should be shown.
        
        - showConstraints : shc          (bool)          [create,query,edit]
            Show constraint relationships in the DAG.
        
        - showDeformers : shd            (bool)          [create,query,edit]
            Show deformer or geometry filter relationships in the DAG.
        
        - showExpressions : shx          (bool)          [create,query,edit]
            Show expression relationships in the DAG.
        
        - showInvisible : shi            (bool)          [create,query,edit]
            Show invisible nodes in the DAG.
        
        - showRelationships : shr        (bool)          [create,query,edit]
            Show relationship (message) connections.
        
        - showShapes : shs               (bool)          [create,query,edit]
            Show shape nodes in the DAG.
        
        - showUnderworld : shu           (bool)          [create,query,edit]
            Show underworld graphs in the DAG.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - toAttr : tat                   (unicode)       [query]
            Returns the name of the destination attribute in a drag and drop connection,
            when called during processing of a drop.
        
        - toNode : ton                   (unicode)       [query]
            Returns the name of the destination node in a drag and drop connection, when
            called during processing of a drop.
        
        - transitionFrames : tfr         (int)           [create,query,edit]
            Specify te number of transition frames for animate transitions.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unfold : uf                    (bool)          [create,edit]
            Unfolds (expands) selected object.
        
        - unfoldAll : ua                 (bool)          [create,edit]
            Unfolds everything under selected object.
        
        - unfoldAllShapes : uas          (bool)          [create,edit]
            Unfolds all shapes.
        
        - unfoldHidden : ufh             (bool)          [create,edit]
            Unfolds all hidden objects.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - updateNodeAdded : una          (bool)          [create,query,edit]
            Update graph when a new node is added to the database
        
        - updateSelection : us           (bool)          [create,query,edit]
            Update selection state in the graph when the selection state of database
            changes.
        
        - upstream : ups                 (bool)          [create,edit]
            Show upstream dependency graph of selected node(s).
        
        - useDrawOverrideColor : drc     (bool)          [create,edit]
            Specify whether or not to use draw override coloring.
        
        - useFeedbackList : ufl          (bool)          [create,query,edit]
            Use feedback or highlight list as the target selection when processing other
            hypergraph command-line options.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - viewOption : vo                (unicode)       [create,query,edit]
            Set or query the view option for this hyper graph editor. The currently allowed
            views are asIconsand asList.
        
        - visibility : vis               (bool)          [create,edit]
            Set the visible state of the selected node(s).
        
        - zoom : zm                      (float)         [create,edit]
            Specify the zoom factor for animating transitions                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.hyperGraph`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'hyperGraph'
    
    
    __melui__ = 'hyperGraph'


class RadioCollection(PyUI):
    def getCollectionItemArray(self, **kwargs):
        """
        Return a string list giving the long names of all the items in this collection.                  
        
        
        Derived from mel command `maya.cmds.radioCollection`
        """
        pass
    def getGl(self, **kwargs):
        """
        Set the collection to have no parent layout.  Global collections must be explicitly deleted.                  
        
        
        Derived from mel command `maya.cmds.radioCollection`
        """
        pass
    def getNumberOfCollectionItems(self, **kwargs):
        """
        Return the number of items in this collection.                  
        
        
        Derived from mel command `maya.cmds.radioCollection`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Select the specified collection item.  If queried will return the name of the currently selected collection item.                  
        
        
        Derived from mel command `maya.cmds.radioCollection`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Select the specified collection item.  If queried will return the name of the currently selected collection item.                  
        
        
        Derived from mel command `maya.cmds.radioCollection`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a radio button collection. Collections are parented to the
        current default layout if no parent is specified with the -p/parentflag.  As
        children of the layout they will be deleted when the layout is deleted.
        Collections may also span more than one window if the -gl/globalflag is used. In
        this case the collection has no parent and must be explicitly deleted with the
        deleteUIcommand when it is no longer wanted.
        
        Flags:
        - collectionItemArray : cia      (bool)          [query]
            Return a string list giving the long names of all the items in this collection.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - gl : gl                        (bool)          [create,query]
            Set the collection to have no parent layout.  Global collections must be
            explicitly deleted.
        
        - numberOfCollectionItems : nci  (bool)          [query]
            Return the number of items in this collection.
        
        - parent : p                     (unicode)       [create]
            The parent of the collection.  The collection will be deleted along with the
            parent.
        
        - select : sl                    (unicode)       [create,query,edit]
            Select the specified collection item.  If queried will return the name of the
            currently selected collection item.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.radioCollection`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'radioCollection'
    
    
    __melui__ = 'radioCollection'


class GradientControl(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getAdaptiveScaling(self, **kwargs):
        """
        Allow the ramp widget display to scale vertically to accommodate values greater than 1.0. True if adaptive scaling is enabled, false (the default) if not.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getNumberOfControls(self, **kwargs):
        """
        Returns the number of controls in the ramp widget                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getRefreshOnRelease(self, **kwargs):
        """
        Define how updates are dispatched during interactive editing of the ramp widget. True causes updates to only dispatch after releasing the mouse button after editing. False (the default) causes updates to dispatch interactively during editing (e.g. while moving ramp curve points). Note that the global update mode, if set to on releasecan disable the effect of this option.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getStaticNumberOfControls(self, **kwargs):
        """
        When 'true', this flag disables the creation/deletion of ramp entries (control points) via ramp widget interaction. Default is false.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getStaticPositions(self, **kwargs):
        """
        When 'true', this flag disables the interactive modification of ramp entry positions. Default is false.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getUpperLimitControl(self, **kwargs):
        """
        Specify the name of a text control which is updated with the current upper display limit for the ramp. This option is only effective when adaptiveScaling is specified.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getVerticalLayout(self, **kwargs):
        """
        When 'true', this makes the control orient vertically rather than horizontally. The default is `false` or horizontal.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def selectedColorControl(self, val='True', **kwargs):
        """
        Specifies the name of a color control to edit the selected color.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def selectedInterpControl(self, val='True', **kwargs):
        """
        Specifies the name of an enum control to edit the selected interpolation.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def selectedPositionControl(self, val='True', **kwargs):
        """
        Specifies the name of a float slider to edit the selected position.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setAdaptiveScaling(self, val='True', **kwargs):
        """
        Allow the ramp widget display to scale vertically to accommodate values greater than 1.0. True if adaptive scaling is enabled, false (the default) if not.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setRefreshOnRelease(self, val='True', **kwargs):
        """
        Define how updates are dispatched during interactive editing of the ramp widget. True causes updates to only dispatch after releasing the mouse button after editing. False (the default) causes updates to dispatch interactively during editing (e.g. while moving ramp curve points). Note that the global update mode, if set to on releasecan disable the effect of this option.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setStaticNumberOfControls(self, val='True', **kwargs):
        """
        When 'true', this flag disables the creation/deletion of ramp entries (control points) via ramp widget interaction. Default is false.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setStaticPositions(self, val='True', **kwargs):
        """
        When 'true', this flag disables the interactive modification of ramp entry positions. Default is false.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setUpperLimitControl(self, val='True', **kwargs):
        """
        Specify the name of a text control which is updated with the current upper display limit for the ramp. This option is only effective when adaptiveScaling is specified.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setVerticalLayout(self, val='True', **kwargs):
        """
        When 'true', this makes the control orient vertically rather than horizontally. The default is `false` or horizontal.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a control that displays the gradient attribute specified.
        The gradient attribute must be of the correct form and naming. It should be a
        multi attribute with each entry a compound composed of: Either a color compound
        or a float value (the control will automatically detect which and display a ramp
        or graph accordingly).A single float attribute for position.An enum for the
        interpolation types.Currently the routines to get the value of a ramp structure
        (with interpolation) are not available through MEL, which limits the use of this
        control by end users. The MEL command AEaddRampControl should be used to attach
        this control to an attribute from attribute editor templates.
        
        Flags:
        - adaptiveScaling : adaptiveScaling (bool)          [create,query,edit]
            Allow the ramp widget display to scale vertically to accommodate values greater
            than 1.0. True if adaptive scaling is enabled, false (the default) if not.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attribute : at                 (PyNode)        [create]
            Specifies the name of the gradient attribute to control.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfControls : nc          (int)           [query]
            Returns the number of controls in the ramp widget
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - refreshOnRelease : ror         (int)           [create,query,edit]
            Define how updates are dispatched during interactive editing of the ramp widget.
            True causes updates to only dispatch after releasing the mouse button after
            editing. False (the default) causes updates to dispatch interactively during
            editing (e.g. while moving ramp curve points). Note that the global update mode,
            if set to on releasecan disable the effect of this option.
        
        - selectedColorControl : scc     (unicode)       [create,edit]
            Specifies the name of a color control to edit the selected color.
        
        - selectedInterpControl : sic    (unicode)       [create,edit]
            Specifies the name of an enum control to edit the selected interpolation.
        
        - selectedPositionControl : spc  (unicode)       [create,edit]
            Specifies the name of a float slider to edit the selected position.
        
        - staticNumberOfControls : snc   (bool)          [create,query,edit]
            When 'true', this flag disables the creation/deletion of ramp entries (control
            points) via ramp widget interaction. Default is false.
        
        - staticPositions : sp           (bool)          [create,query,edit]
            When 'true', this flag disables the interactive modification of ramp entry
            positions. Default is false.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - upperLimitControl : ulc        (unicode)       [create,query,edit]
            Specify the name of a text control which is updated with the current upper
            display limit for the ramp. This option is only effective when adaptiveScaling
            is specified.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - verticalLayout : vl            (bool)          [create,query,edit]
            When 'true', this makes the control orient vertically rather than horizontally.
            The default is `false` or horizontal.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.gradientControl`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'gradientControl'
    
    
    __melui__ = 'gradientControl'


class ClipEditor(PyUI):
    def clipDropCmd(self, val='True', **kwargs):
        """
        Command executed when clip node is dropped on the TraX editor                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def deleteCmd(self, val='True', **kwargs):
        """
        Command executed when backspacekey is pressed                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def deselectAll(self, val='True', **kwargs):
        """
        Deselect all clips and blends in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def displayActiveKeyTangents(self, val='True', **kwargs):
        """
        on | off | tgl Display active key tangents in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def displayActiveKeys(self, val='True', **kwargs):
        """
        on | off | tgl Display active keys in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def displayInfinities(self, val='True', **kwargs):
        """
        on | off | tgl Display infinities in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def displayKeys(self, val='True', **kwargs):
        """
        on | off | tgl Display keyframes in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def displayTangents(self, val='True', **kwargs):
        """
        on | off | tgl Display tangents in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def displayValues(self, val='True', **kwargs):
        """
        on | off | tgl Display active keys and tangents values in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def frameAll(self, val='True', **kwargs):
        """
        Frame view around all clips in the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getAutoFit(self, **kwargs):
        """
        on | off | tgl Auto fit-to-view.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getAutoFitTime(self, **kwargs):
        """
        on | off | tgl Auto fit-to-view along the time axis, as well.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getClipStyle(self, **kwargs):
        """
        Set/return the clip track style in the specified editor. Default is 2. Valid values are 1-3.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getFrameRange(self, **kwargs):
        """
        The editor's current frame range.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getHighlightedBlend(self, **kwargs):
        """
        Returns the highlighted blend, listed as scheduler and index                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getHighlightedClip(self, **kwargs):
        """
        Returns the highlighted clip, listed as scheduler and index                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getInitialized(self, **kwargs):
        """
        Returns whether the clip editor is fully initialized, and has a port to draw through. If not, the -frameRange and -frameAll flags will fail.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getManageSequencer(self, **kwargs):
        """
        Sets/returns whether the clip editor should manage sequencer nodes.  If so, animation clips and characters are not represented.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getMenuContext(self, **kwargs):
        """
        Returns a string array denoting the type of data object the cursor is over.  Returned values are: timeSlider nothing track, track index, character node name, group name clip, clip node name                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getSelectBlend(self, **kwargs):
        """
        Select the blends specified by the scheduler name and the indicies of the two clips used in the blend. When queried, a string containing the scheduler name and the two clip indicies for all of the selected blends is returned.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getSelectClip(self, **kwargs):
        """
        Selects the clip specified by the scheduler name and the clip index. When queried, a string containing the scheduler and clip index of all of the selected clips is returned.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getSnapTime(self, **kwargs):
        """
        none | integer | keyframe Keyframe move snap in time.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getSnapValue(self, **kwargs):
        """
        none | integer | keyframe Keyframe move snap in values.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def listAllCharacters(self, val='True', **kwargs):
        """
        List all characters in the editor and outliner.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def listCurrentCharacters(self, val='True', **kwargs):
        """
        List only the characters in the editor and outliner.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def lookAt(self, val='True', **kwargs):
        """
        all | selected | currentTime FitView helpers.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setAutoFit(self, val='True', **kwargs):
        """
        on | off | tgl Auto fit-to-view.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setAutoFitTime(self, val='True', **kwargs):
        """
        on | off | tgl Auto fit-to-view along the time axis, as well.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setClipStyle(self, val='True', **kwargs):
        """
        Set/return the clip track style in the specified editor. Default is 2. Valid values are 1-3.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setFrameRange(self, val='True', **kwargs):
        """
        The editor's current frame range.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setManageSequencer(self, val='True', **kwargs):
        """
        Sets/returns whether the clip editor should manage sequencer nodes.  If so, animation clips and characters are not represented.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setSelectBlend(self, val='True', **kwargs):
        """
        Select the blends specified by the scheduler name and the indicies of the two clips used in the blend. When queried, a string containing the scheduler name and the two clip indicies for all of the selected blends is returned.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setSelectClip(self, val='True', **kwargs):
        """
        Selects the clip specified by the scheduler name and the clip index. When queried, a string containing the scheduler and clip index of all of the selected clips is returned.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setSnapTime(self, val='True', **kwargs):
        """
        none | integer | keyframe Keyframe move snap in time.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def setSnapValue(self, val='True', **kwargs):
        """
        none | integer | keyframe Keyframe move snap in values.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a clip editor with the given name.
        
        Flags:
        - allTrackHeights : th           (int)           []
            OBSOLETE flag. Use clipStyle instead.
        
        - autoFit : af                   (unicode)       [query,edit]
            on | off | tgl Auto fit-to-view.
        
        - autoFitTime : aft              (unicode)       [query,edit]
            on | off | tgl Auto fit-to-view along the time axis, as well.
        
        - characterOutline : co          (unicode)       []
        
        - clipDropCmd : cd               (unicode)       [edit]
            Command executed when clip node is dropped on the TraX editor
        
        - clipStyle : cs                 (int)           [query,edit]
            Set/return the clip track style in the specified editor. Default is 2. Valid
            values are 1-3.
        
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteCmd : dc                 (unicode)       [edit]
            Command executed when backspacekey is pressed
        
        - deselectAll : da               (bool)          [edit]
            Deselect all clips and blends in the editor.
        
        - displayActiveKeyTangents : dat (unicode)       [edit]
            on | off | tgl Display active key tangents in the editor.
        
        - displayActiveKeys : dak        (unicode)       [edit]
            on | off | tgl Display active keys in the editor.
        
        - displayInfinities : di         (unicode)       [edit]
            on | off | tgl Display infinities in the editor.
        
        - displayKeys : dk               (unicode)       [edit]
            on | off | tgl Display keyframes in the editor.
        
        - displayTangents : dtn          (unicode)       [edit]
            on | off | tgl Display tangents in the editor.
        
        - displayValues : dv             (unicode)       [edit]
            on | off | tgl Display active keys and tangents values in the editor.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - frameAll : fa                  (bool)          [edit]
            Frame view around all clips in the editor.
        
        - frameRange : fr                (float, float)  [query,edit]
            The editor's current frame range.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - highlightedBlend : hb          (unicode, unicode) [query]
            Returns the highlighted blend, listed as scheduler and index
        
        - highlightedClip : hc           (unicode, unicode) [query]
            Returns the highlighted clip, listed as scheduler and index
        
        - initialized : it               (bool)          [query]
            Returns whether the clip editor is fully initialized, and has a port to draw
            through. If not, the -frameRange and -frameAll flags will fail.
        
        - listAllCharacters : lac        (bool)          [edit]
            List all characters in the editor and outliner.
        
        - listCurrentCharacters : lc     (bool)          [edit]
            List only the characters in the editor and outliner.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - lookAt : la                    (unicode)       [edit]
            all | selected | currentTime FitView helpers.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - manageSequencer : ms           (bool)          [create,query,edit]
            Sets/returns whether the clip editor should manage sequencer nodes.  If so,
            animation clips and characters are not represented.
        
        - menuContext : mc               (unicode)       [query]
            Returns a string array denoting the type of data object the cursor is over.
            Returned values are: timeSlider nothing track, track index, character node name,
            group name clip, clip node name
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - selectBlend : sb               (unicode, unicode, unicode) [query,edit]
            Select the blends specified by the scheduler name and the indicies of the two
            clips used in the blend. When queried, a string containing the scheduler name
            and the two clip indicies for all of the selected blends is returned.
        
        - selectClip : sc                (unicode, unicode) [query,edit]
            Selects the clip specified by the scheduler name and the clip index. When
            queried, a string containing the scheduler and clip index of all of the selected
            clips is returned.
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - snapTime : st                  (unicode)       [query,edit]
            none | integer | keyframe Keyframe move snap in time.
        
        - snapValue : sv                 (unicode)       [query,edit]
            none | integer | keyframe Keyframe move snap in values.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.clipEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'clipEditor'
    
    
    __melui__ = 'clipEditor'


class Separator(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getHorizontal(self, **kwargs):
        """
        Specify the orientation of the separator.  True for horizontal and false for vertical.  Only valid when style equals single.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getStyle(self, **kwargs):
        """
        Specify the style of the separator.  Valid values are none, single, in, outand shelf.  Note: the values double, singleDashand doubleDashand no longer supported.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        Specify the style of the separator.  Valid values are none, single, in, outand shelf.  Note: the values double, singleDashand doubleDashand no longer supported.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a separator widget in a variety of drawing styles.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontal : hr                (bool)          [create,query]
            Specify the orientation of the separator.  True for horizontal and false for
            vertical.  Only valid when style equals single.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            Specify the style of the separator.  Valid values are none, single, in, outand
            shelf.  Note: the values double, singleDashand doubleDashand no longer
            supported.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.separator`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'separator'
    
    
    __melui__ = 'separator'


class FloatField(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the field changes.  This command is not invoked when the value changes via the -v/valueflag.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command executed when dragging in the field.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def enterCommand(self, val='True', **kwargs):
        """
        Command executed when the keypad 'Enter' key is pressed.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it.  If false then the field can not be changed interactively.  However, you can change the field text with the -v/valueflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Upper limit of the field.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Lower limit of the field.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getPrecision(self, **kwargs):
        """
        Number of digits to the right of the decimal place.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getShowTrailingZeros(self, **kwargs):
        """
        Show trailing zeros or not                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getStep(self, **kwargs):
        """
        Increment for the invisible slider.   The field value will change by this amount when the invisible slider is dragged.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the field.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def receiveFocusCommand(self, val='True', **kwargs):
        """
        Command executed when the field receives focus.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it.  If false then the field can not be changed interactively.  However, you can change the field text with the -v/valueflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Upper limit of the field.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Lower limit of the field.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setPrecision(self, val='True', **kwargs):
        """
        Number of digits to the right of the decimal place.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setShowTrailingZeros(self, val='True', **kwargs):
        """
        Show trailing zeros or not                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Increment for the invisible slider.   The field value will change by this amount when the invisible slider is dragged.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the field.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a field control that accepts only float values and is bound by a minimum
        and maximum value.  An invisible slider is attached to the field and accessed by
        holding down the Ctrl modifier key while pressing one of the mouse buttons.
        Dragging the invisible slider to the right with the middle mouse button
        increases the field value by the amount specified with the -s/stepflag, while
        dragging to the left decreases the value by the same amount.  The left and right
        mouse buttons apply a factor of 0.1 and 10 to the step value.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the field changes.  This command is not invoked when the
            value changes via the -v/valueflag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command executed when dragging in the field.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the field.  By default, this flag is set to true and the field
            value may be changed by typing into it.  If false then the field can not be
            changed interactively.  However, you can change the field text with the
            -v/valueflag regardless of the state of the -ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enterCommand : ec              (script)        [create,edit]
            Command executed when the keypad 'Enter' key is pressed.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (float)         [create,query,edit]
            Upper limit of the field.
        
        - minValue : min                 (float)         [create,query,edit]
            Lower limit of the field.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [create,query,edit]
            Number of digits to the right of the decimal place.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - receiveFocusCommand : rfc      (script)        [create,edit]
            Command executed when the field receives focus.
        
        - showTrailingZeros : tze        (bool)          [create,query,edit]
            Show trailing zeros or not
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            Increment for the invisible slider.   The field value will change by this amount
            when the invisible slider is dragged.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (float)         [create,query,edit]
            Value of the field.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.floatField`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'floatField'
    
    
    __melui__ = 'floatField'


class NameField(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getChangeCommand(self, **kwargs):
        """
        This command is executed when the field text is changed by the user.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getDrawInactiveFrame(self, **kwargs):
        """
        Sets whether the name field draws itself with a frame when it is inactive. By default, this option is false.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getNameChangeCommand(self, **kwargs):
        """
        This command is executed when the name of the node changes. NOTE: this will be executed when the node name changes, whether or not the name-change originated with the user typing into the field. If you want to attach a command to be executed when the user types into the field, use the -cc/changeCommand flag.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getObject(self, **kwargs):
        """
        Attaches the field to the named dage object, so that the field will always display the object's name.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getReceiveFocusCommand(self, **kwargs):
        """
        Command executed when the field receives focus.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setChangeCommand(self, val='True', **kwargs):
        """
        This command is executed when the field text is changed by the user.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setDrawInactiveFrame(self, val='True', **kwargs):
        """
        Sets whether the name field draws itself with a frame when it is inactive. By default, this option is false.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setNameChangeCommand(self, val='True', **kwargs):
        """
        This command is executed when the name of the node changes. NOTE: this will be executed when the node name changes, whether or not the name-change originated with the user typing into the field. If you want to attach a command to be executed when the user types into the field, use the -cc/changeCommand flag.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setObject(self, val='True', **kwargs):
        """
        Attaches the field to the named dage object, so that the field will always display the object's name.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setReceiveFocusCommand(self, val='True', **kwargs):
        """
        Command executed when the field receives focus.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates an editable field that can be linked to the name of a Maya
        object. The field will always show the name of the object.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,query,edit]
            This command is executed when the field text is changed by the user.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - drawInactiveFrame : dif        (bool)          [create,query,edit]
            Sets whether the name field draws itself with a frame when it is inactive. By
            default, this option is false.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - nameChangeCommand : ncc        (script)        [create,query,edit]
            This command is executed when the name of the node changes. NOTE: this will be
            executed when the node name changes, whether or not the name-change originated
            with the user typing into the field. If you want to attach a command to be
            executed when the user types into the field, use the -cc/changeCommand flag.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - object : o                     (unicode)       [create,query,edit]
            Attaches the field to the named dage object, so that the field will always
            display the object's name.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - receiveFocusCommand : rfc      (script)        [create,query,edit]
            Command executed when the field receives focus.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.nameField`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'nameField'
    
    
    __melui__ = 'nameField'


class OutlinerEditor(PyUI):
    def allowMultiSelection(self, val='True', **kwargs):
        """
        If true then multiple selection will be allowed in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def alwaysToggleSelect(self, val='True', **kwargs):
        """
        If true, then clicking on an item in the outliner will select or deselect it without affecting the selection of other items (unless allowMultiSelection is false). If false, clicking on an item in the outliner will replace the current selection with the selected item.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def directSelect(self, val='True', **kwargs):
        """
        If true then clicking on an item in the outliner will add or remove just that item from the selection connection. If false then clicking on an item in the outliner causes the selection connection to be reloaded with the currently selected items in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def expandAllItems(self, val='True', **kwargs):
        """
        Expand or collapse all items in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def expandAllSelectedItems(self, val='True', **kwargs):
        """
        Expand or collapse all selected items in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def expandAttribute(self, val='True', **kwargs):
        """
        Force the outliner to fill the selection list with only attributes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getAnimLayerFilterOptions(self, **kwargs):
        """
        Specifies whether a filter is to be applied when displaying animation layers. If so, the options can be allAffecting(no filter), active(only the active layers on the object will be displayed) and animLayerEditor(the settings will be taken from the animation layer editor).                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getAttrAlphaOrder(self, **kwargs):
        """
        Specify how attributes are to be sorted. Current recognised values are defaultfor no sorting and ascendto sort attributes from 'a' to ''z' and descendto sort from 'z' to 'a'. Notes: a) this only applies to top level attributes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getAttrFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be placed on this editor. This filters the attributes displayed in the editor.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getAutoExpand(self, **kwargs):
        """
        This flag specifies whether or not objects that are loaded in should have their attributes automatically expanded.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getAutoExpandLayers(self, **kwargs):
        """
        If true then when a node with animation layer is displayed, all the animation layers will show up in expanded form.                   
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getAutoSelectNewObjects(self, **kwargs):
        """
        This flag specifies whether or not new objects added to the outliner should be automatically selected.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getContainersIgnoreFilters(self, **kwargs):
        """
        This flag specifices whether or not filters should be ignored when displaying container contents.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getDisplayMode(self, **kwargs):
        """
        Affects how the outliner displays when a filter is applied. List mode is a non-indented flat list. DAG mode indents to represent the hierarchical structure of the model.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getDoNotSelectNewObjects(self, **kwargs):
        """
        If true this flag specifies that new objects added to the outliner will not be selected, even if they are active.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getDropIsParent(self, **kwargs):
        """
        This flag specifies the mode for drag and drop. If the flag is true, dropping items will do a reparent. If it is false, dropping will reorder items. By default, the flag is true (parent).                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getEditAttrName(self, **kwargs):
        """
        This flag specifies whether or not attribute names can be edited. By default double-clicking on an attribute will open the expression editor for that attribute.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getExpandConnections(self, **kwargs):
        """
        This flag specifies whether or not attributes should be expanded to show their input connections. Note: currently the expansion will only show animCurves.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getExpandObjects(self, **kwargs):
        """
        This flag specifies whether or not objects that are loaded in should be automatically expanded.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getFeedbackItemName(self, **kwargs):
        """
        Returns the outliner item name at the current mouse position, if any.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getFeedbackRowNumber(self, **kwargs):
        """
        Returns the outliner row number at the current mouse position, if any.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getGetCurrentSetOfItem(self, **kwargs):
        """
        Returns the current set of item at the given row. As an item can belong to number of sets, current set is the set to which the item belongs to currently.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getHighlightActive(self, **kwargs):
        """
        This flag specifies whether or not the outliner should highlight objects that are active. Note: if the outliner is driving the contents of another editor, setting highlightActive to true may produce unexpected behavior.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getHighlightSecondary(self, **kwargs):
        """
        This flag specifies whether or not the outliner should highlight objects that are contained in the highlightConnection.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getIgnoreDagHierarchy(self, **kwargs):
        """
        This flag specifies whether or not DAG objects are displayed in their DAG hierarchy. Warning: using this flag without some other form of sensible filtering will lead to a very confusing outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getIgnoreHiddenAttribute(self, **kwargs):
        """
        Sets whether or not the outliner ignores the 'hidden in outliner' flag on nodes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getIgnoreOutlinerColor(self, **kwargs):
        """
        Sets whether or not the outliner ignores the 'use outliner color' flag on nodes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getIsChildSelected(self, **kwargs):
        """
        This flag allows you to query if one or more of the children of the specified item is selected in the outliner. The item should be specified using a unique DAG path. Note that if the specified item appears multiple times in the outliner, the result will be true if one or more children of any occurrence of the specified item in the outliner is/are selected.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getIsSet(self, **kwargs):
        """
        Returns true if the item present at the given row is a set.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getIsSetMember(self, **kwargs):
        """
        Returns true if the item present at the given row is a set member.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getLongNames(self, **kwargs):
        """
        Controls whether long or short attribute names will be used in the interface.  Note that this flag is ignored if the -niceNames flag is set.  Default is short names. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getMapMotionTrails(self, **kwargs):
        """
        Sets whether or not we replace the motion trail in the outliner with the object it is trailing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getMasterOutliner(self, **kwargs):
        """
        This flag is the name of an outliner that this outliner will share the objects and state from. When an outliner is shared, all of its state information comes from, and is applied to, the master outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getNiceNames(self, **kwargs):
        """
        Controls whether the attribute names will be displayed in a more user-friendly, readable way.  When this is on, the longNames flag is ignored.  When this is off, attribute names will be displayed either long or short, according to the longNames flag. Default is on. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getObject(self, **kwargs):
        """
        This flags is used together with the parentObjectflag to get the name of the parent object for the specified object.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getOrganizeByClip(self, **kwargs):
        """
        If true then when a node with Time Editor clips is displayed, attributes will be displayed according to the clip(s) it belongs to. eg:  Clip1 Attr1 Attr2 Clip2 Attr1  If it is false then the outliner will be organized primarily by attributes. eg:  Attr1 Clip1 Clip2 Attr2 Clip1                   
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getOrganizeByLayer(self, **kwargs):
        """
        If true then when a node with animation layer is displayed, attributes will be displayed according to the layer(s) it belongs to. eg:  Layer1 Attr1 Attr2 Layer2 Attr1  If it is false then the outliner will be organized primarily by attributes. eg:  Attr1 Layer1 Layer2 Attr2 Layer1                   
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getParentObject(self, **kwargs):
        """
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getPinPlug(self, **kwargs):
        """
        Pins the named plug, so it always appears in the outliner, irrespective of the incoming selection connection. In query mode, returns a list of the pinned plugs.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getRenderFilterActive(self, **kwargs):
        """
        This is a query only flag which returns true if the render setup filter is Active, i.e one of the four render filters (Inside Selected, Outside Selected, Inside All Layers, Outside All Layers) is applied on the outliner currently, false otherwise.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getRenderFilterIndex(self, **kwargs):
        """
        Sets the Render Setup Filter to the index passed. This only works if the filter is visible in outliner and its selection is not locked. Valid indices are: 0 - Scene2 - Inside Selected3 - Outside Selected4 - Inside All Layers5 - Outside All LayersDefault: Scene 0 In query mode returns current index of the filter.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getRenderFilterVisible(self, **kwargs):
        """
        Show/Hide the Render Setup Filter in outliner. In query mode returns whether the Render Setup Filter is visible or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getSelectCommand(self, **kwargs):
        """
        A command to be executed when an item is selected.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getSetFilter(self, **kwargs):
        """
        Specifies the name of a filter which is used to filter which (if any) sets to display.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getSetsIgnoreFilters(self, **kwargs):
        """
        This flag specifies whether or not the filter should be ignored for expanding sets to show set members (default is true).                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowAnimCurvesOnly(self, **kwargs):
        """
        This flag modifies the showConnected flag.  If showConnected is set to true then this flag will cause display of only those attributes that are connected to an animCurve. If showConnected is set to false then this flag does nothing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowAnimLayerWeight(self, **kwargs):
        """
        If true then when a node with animation layer is displayed, the weight of the layer will be displayed if it is keyed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowAssets(self, **kwargs):
        """
        This flags specifies whether assets should be shown in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowAssignedMaterials(self, **kwargs):
        """
        Specifies whether to show assigned materials under shapes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowAttrValues(self, **kwargs):
        """
        This flag specifies whether attribute values or attribute names should be displayed. Note: currently only string attributes can have their values displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowAttributes(self, **kwargs):
        """
        Specifies whether to show attributes or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowCompounds(self, **kwargs):
        """
        This flag specifies whether or not compound attributes should be displayed, or just the leaf attributes. Note: if showConnected is true, and the compound attribute is connected, it will still be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowConnected(self, **kwargs):
        """
        This flag modifies the showAttributes flag.  If showAttributes is set to true then this flag will cause display of only those attributes that are connected in the dependency graph. If showAttributes is set to false then this flag does nothing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowContainedOnly(self, **kwargs):
        """
        This flags specifies whether nodes belonging to containers should be show under the container node only. Otherwise, it will show up under the world as well.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowContainerContents(self, **kwargs):
        """
        This flags specifies whether the contents of the container should be shown under the container node in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowDagOnly(self, **kwargs):
        """
        This flag specifies whether all dependency graph objects will be displayed, or just DAG objects.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowLeafs(self, **kwargs):
        """
        This flag specifies whether or not leaf attributes should be displayed, or just the compound attributes. Note: if showConnected is true, and the leaf attribute is connected, it will still be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowMuteInfo(self, **kwargs):
        """
        This flag specifies whether mute information will be displayed                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowNamespace(self, **kwargs):
        """
        This flag specifies whether all objects will have their namespace displayed, if namespace different than root.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowNumericAttrsOnly(self, **kwargs):
        """
        This flag specifies whether or not all attributes should be displayed, or just numeric attributes. Note: if showConnected is true, and the attribute is connected, it will still be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowParentContainers(self, **kwargs):
        """
        This flags specifies whether nodes belonging to containers/assets should show their containers/assets as well in its outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowPinIcons(self, **kwargs):
        """
        Sets whether pin icons are shown for unpinned plugs.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowPublishedAsConnected(self, **kwargs):
        """
        This flags enables attributes that are published to be displayed in italics. Otherwise, only attributes connected as a destination are shown in italics.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowReferenceMembers(self, **kwargs):
        """
        Specifies whether to show reference node members under the reference node in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowReferenceNodes(self, **kwargs):
        """
        Specifies whether to show reference nodes or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowSetMembers(self, **kwargs):
        """
        If true then when a set is expanded, the set members will be displayed. If false, then only other sets will be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowShapes(self, **kwargs):
        """
        Specifies whether to show shapes or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowTextureNodesOnly(self, **kwargs):
        """
        This flag modifies the showConnected flag. If showConnected is set to true then this flag will cause display of only those attributes that are connected to a texture node. If showConnected is set to false then this flag does nothing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowTimeEditor(self, **kwargs):
        """
        If true, all nodes related to the Time Editor will be shown as a hierarchy.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowUVAttrsOnly(self, **kwargs):
        """
        This flag specifies whether or not all attributes should be displayed, or just uv attributes. Note: currently the only attribute which will be displayed is Shape.uvSet.uvSetName.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowUnitlessCurves(self, **kwargs):
        """
        This flag (in combination with -expandConnections) specifies whether or not connection expansion should show unitless animCurves.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getShowUpstreamCurves(self, **kwargs):
        """
        Specifies exactly which attributes are displayed when showAttributes and expandConnections are both true. If true, the dependency graph is searched upstream for all curves that drive the selected plugs (showing multiple curves for example in a typical driven key setup, where first the driven key curve is encountered, followed by the actual animation curve that drives the source object). If false, only the first curves encountered will be shown. Note that, even if false, multiple curves can be shown if e.g. a blendWeighted node is being used to combine multiple curves.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getSortOrder(self, **kwargs):
        """
        Specify how objects are to be sorted.  Current recognised values are nonefor no sorting and dagNameto sort DAG objects by name. Notes: a) non-DAG objects are always sorted by nodeType and name. b) when sortOrder is set to dagName, objects cannot be reordered using drag-and-drop, they can however be reparented.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def getTransmitFilters(self, **kwargs):
        """
        This flag specifies how the selectionConnection is populated when attribute filters are enabled.  If this flag is set to true, then all the attributes that pass the filter will be placed on the selectionConnection.  By default this flag is false.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def refresh(self, val='True', **kwargs):
        """
        Causes the outliner to refresh itself.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def removeFromCurrentSet(self, val='True', **kwargs):
        """
        Removes selected members of a set from their current set. Current set is the set to which item at the given row belongs to. If no selected items, the item at the given row is removed from its current set.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def renameItem(self, val='True', **kwargs):
        """
        Renames the item at the given row index in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def renameSelectedItem(self, val='True', **kwargs):
        """
        Rename the first selected item in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def selectionOrder(self, val='True', **kwargs):
        """
        Specify how objects are sorted in selection list. Current recognised values are chronologicalfor sorting in selection order and displayto sort objects in the same order that the outliner does.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setAnimLayerFilterOptions(self, val='True', **kwargs):
        """
        Specifies whether a filter is to be applied when displaying animation layers. If so, the options can be allAffecting(no filter), active(only the active layers on the object will be displayed) and animLayerEditor(the settings will be taken from the animation layer editor).                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setAttrAlphaOrder(self, val='True', **kwargs):
        """
        Specify how attributes are to be sorted. Current recognised values are defaultfor no sorting and ascendto sort attributes from 'a' to ''z' and descendto sort from 'z' to 'a'. Notes: a) this only applies to top level attributes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setAttrFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be placed on this editor. This filters the attributes displayed in the editor.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setAutoExpand(self, val='True', **kwargs):
        """
        This flag specifies whether or not objects that are loaded in should have their attributes automatically expanded.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setAutoExpandLayers(self, val='True', **kwargs):
        """
        If true then when a node with animation layer is displayed, all the animation layers will show up in expanded form.                   
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setAutoSelectNewObjects(self, val='True', **kwargs):
        """
        This flag specifies whether or not new objects added to the outliner should be automatically selected.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setContainersIgnoreFilters(self, val='True', **kwargs):
        """
        This flag specifices whether or not filters should be ignored when displaying container contents.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setDisplayMode(self, val='True', **kwargs):
        """
        Affects how the outliner displays when a filter is applied. List mode is a non-indented flat list. DAG mode indents to represent the hierarchical structure of the model.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setDoNotSelectNewObjects(self, val='True', **kwargs):
        """
        If true this flag specifies that new objects added to the outliner will not be selected, even if they are active.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setDropIsParent(self, val='True', **kwargs):
        """
        This flag specifies the mode for drag and drop. If the flag is true, dropping items will do a reparent. If it is false, dropping will reorder items. By default, the flag is true (parent).                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setEditAttrName(self, val='True', **kwargs):
        """
        This flag specifies whether or not attribute names can be edited. By default double-clicking on an attribute will open the expression editor for that attribute.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setExpandConnections(self, val='True', **kwargs):
        """
        This flag specifies whether or not attributes should be expanded to show their input connections. Note: currently the expansion will only show animCurves.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setExpandObjects(self, val='True', **kwargs):
        """
        This flag specifies whether or not objects that are loaded in should be automatically expanded.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setHighlightActive(self, val='True', **kwargs):
        """
        This flag specifies whether or not the outliner should highlight objects that are active. Note: if the outliner is driving the contents of another editor, setting highlightActive to true may produce unexpected behavior.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setHighlightSecondary(self, val='True', **kwargs):
        """
        This flag specifies whether or not the outliner should highlight objects that are contained in the highlightConnection.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setIgnoreDagHierarchy(self, val='True', **kwargs):
        """
        This flag specifies whether or not DAG objects are displayed in their DAG hierarchy. Warning: using this flag without some other form of sensible filtering will lead to a very confusing outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setIgnoreHiddenAttribute(self, val='True', **kwargs):
        """
        Sets whether or not the outliner ignores the 'hidden in outliner' flag on nodes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setIgnoreOutlinerColor(self, val='True', **kwargs):
        """
        Sets whether or not the outliner ignores the 'use outliner color' flag on nodes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setLongNames(self, val='True', **kwargs):
        """
        Controls whether long or short attribute names will be used in the interface.  Note that this flag is ignored if the -niceNames flag is set.  Default is short names. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setMapMotionTrails(self, val='True', **kwargs):
        """
        Sets whether or not we replace the motion trail in the outliner with the object it is trailing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setMasterOutliner(self, val='True', **kwargs):
        """
        This flag is the name of an outliner that this outliner will share the objects and state from. When an outliner is shared, all of its state information comes from, and is applied to, the master outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setNiceNames(self, val='True', **kwargs):
        """
        Controls whether the attribute names will be displayed in a more user-friendly, readable way.  When this is on, the longNames flag is ignored.  When this is off, attribute names will be displayed either long or short, according to the longNames flag. Default is on. Queried, returns a boolean.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setOrganizeByClip(self, val='True', **kwargs):
        """
        If true then when a node with Time Editor clips is displayed, attributes will be displayed according to the clip(s) it belongs to. eg:  Clip1 Attr1 Attr2 Clip2 Attr1  If it is false then the outliner will be organized primarily by attributes. eg:  Attr1 Clip1 Clip2 Attr2 Clip1                   
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setOrganizeByLayer(self, val='True', **kwargs):
        """
        If true then when a node with animation layer is displayed, attributes will be displayed according to the layer(s) it belongs to. eg:  Layer1 Attr1 Attr2 Layer2 Attr1  If it is false then the outliner will be organized primarily by attributes. eg:  Attr1 Layer1 Layer2 Attr2 Layer1                   
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setPinPlug(self, val='True', **kwargs):
        """
        Pins the named plug, so it always appears in the outliner, irrespective of the incoming selection connection. In query mode, returns a list of the pinned plugs.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setRenderFilterIndex(self, val='True', **kwargs):
        """
        Sets the Render Setup Filter to the index passed. This only works if the filter is visible in outliner and its selection is not locked. Valid indices are: 0 - Scene2 - Inside Selected3 - Outside Selected4 - Inside All Layers5 - Outside All LayersDefault: Scene 0 In query mode returns current index of the filter.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setRenderFilterVisible(self, val='True', **kwargs):
        """
        Show/Hide the Render Setup Filter in outliner. In query mode returns whether the Render Setup Filter is visible or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setSelectCommand(self, val='True', **kwargs):
        """
        A command to be executed when an item is selected.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setSetFilter(self, val='True', **kwargs):
        """
        Specifies the name of a filter which is used to filter which (if any) sets to display.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setSetsIgnoreFilters(self, val='True', **kwargs):
        """
        This flag specifies whether or not the filter should be ignored for expanding sets to show set members (default is true).                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowAnimCurvesOnly(self, val='True', **kwargs):
        """
        This flag modifies the showConnected flag.  If showConnected is set to true then this flag will cause display of only those attributes that are connected to an animCurve. If showConnected is set to false then this flag does nothing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowAnimLayerWeight(self, val='True', **kwargs):
        """
        If true then when a node with animation layer is displayed, the weight of the layer will be displayed if it is keyed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowAssets(self, val='True', **kwargs):
        """
        This flags specifies whether assets should be shown in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowAssignedMaterials(self, val='True', **kwargs):
        """
        Specifies whether to show assigned materials under shapes.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowAttrValues(self, val='True', **kwargs):
        """
        This flag specifies whether attribute values or attribute names should be displayed. Note: currently only string attributes can have their values displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowAttributes(self, val='True', **kwargs):
        """
        Specifies whether to show attributes or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowCompounds(self, val='True', **kwargs):
        """
        This flag specifies whether or not compound attributes should be displayed, or just the leaf attributes. Note: if showConnected is true, and the compound attribute is connected, it will still be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowConnected(self, val='True', **kwargs):
        """
        This flag modifies the showAttributes flag.  If showAttributes is set to true then this flag will cause display of only those attributes that are connected in the dependency graph. If showAttributes is set to false then this flag does nothing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowContainedOnly(self, val='True', **kwargs):
        """
        This flags specifies whether nodes belonging to containers should be show under the container node only. Otherwise, it will show up under the world as well.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowContainerContents(self, val='True', **kwargs):
        """
        This flags specifies whether the contents of the container should be shown under the container node in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowDagOnly(self, val='True', **kwargs):
        """
        This flag specifies whether all dependency graph objects will be displayed, or just DAG objects.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowLeafs(self, val='True', **kwargs):
        """
        This flag specifies whether or not leaf attributes should be displayed, or just the compound attributes. Note: if showConnected is true, and the leaf attribute is connected, it will still be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowMuteInfo(self, val='True', **kwargs):
        """
        This flag specifies whether mute information will be displayed                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowNamespace(self, val='True', **kwargs):
        """
        This flag specifies whether all objects will have their namespace displayed, if namespace different than root.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowNumericAttrsOnly(self, val='True', **kwargs):
        """
        This flag specifies whether or not all attributes should be displayed, or just numeric attributes. Note: if showConnected is true, and the attribute is connected, it will still be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowParentContainers(self, val='True', **kwargs):
        """
        This flags specifies whether nodes belonging to containers/assets should show their containers/assets as well in its outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowPinIcons(self, val='True', **kwargs):
        """
        Sets whether pin icons are shown for unpinned plugs.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowPublishedAsConnected(self, val='True', **kwargs):
        """
        This flags enables attributes that are published to be displayed in italics. Otherwise, only attributes connected as a destination are shown in italics.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowReferenceMembers(self, val='True', **kwargs):
        """
        Specifies whether to show reference node members under the reference node in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowReferenceNodes(self, val='True', **kwargs):
        """
        Specifies whether to show reference nodes or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowSetMembers(self, val='True', **kwargs):
        """
        If true then when a set is expanded, the set members will be displayed. If false, then only other sets will be displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowShapes(self, val='True', **kwargs):
        """
        Specifies whether to show shapes or not.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowTextureNodesOnly(self, val='True', **kwargs):
        """
        This flag modifies the showConnected flag. If showConnected is set to true then this flag will cause display of only those attributes that are connected to a texture node. If showConnected is set to false then this flag does nothing.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowTimeEditor(self, val='True', **kwargs):
        """
        If true, all nodes related to the Time Editor will be shown as a hierarchy.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowUVAttrsOnly(self, val='True', **kwargs):
        """
        This flag specifies whether or not all attributes should be displayed, or just uv attributes. Note: currently the only attribute which will be displayed is Shape.uvSet.uvSetName.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowUnitlessCurves(self, val='True', **kwargs):
        """
        This flag (in combination with -expandConnections) specifies whether or not connection expansion should show unitless animCurves.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setShowUpstreamCurves(self, val='True', **kwargs):
        """
        Specifies exactly which attributes are displayed when showAttributes and expandConnections are both true. If true, the dependency graph is searched upstream for all curves that drive the selected plugs (showing multiple curves for example in a typical driven key setup, where first the driven key curve is encountered, followed by the actual animation curve that drives the source object). If false, only the first curves encountered will be shown. Note that, even if false, multiple curves can be shown if e.g. a blendWeighted node is being used to combine multiple curves.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setSortOrder(self, val='True', **kwargs):
        """
        Specify how objects are to be sorted.  Current recognised values are nonefor no sorting and dagNameto sort DAG objects by name. Notes: a) non-DAG objects are always sorted by nodeType and name. b) when sortOrder is set to dagName, objects cannot be reordered using drag-and-drop, they can however be reparented.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def setTransmitFilters(self, val='True', **kwargs):
        """
        This flag specifies how the selectionConnection is populated when attribute filters are enabled.  If this flag is set to true, then all the attributes that pass the filter will be placed on the selectionConnection.  By default this flag is false.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def showSelected(self, val='True', **kwargs):
        """
        If true then the selected items are expanded in the outliner.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def unpinPlug(self, val='True', **kwargs):
        """
        Unpins the named plug.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates an outliner editor which can be used to display a list of
        objects.WARNING: some flag combinations may not behave as you expect.  The
        command is really intended for internal use for creating the outliner used by
        the various editors.
        
        Flags:
        - allowMultiSelection : ams      (bool)          [create,edit]
            If true then multiple selection will be allowed in the outliner.
        
        - alwaysToggleSelect : ats       (bool)          [create,edit]
            If true, then clicking on an item in the outliner will select or deselect it
            without affecting the selection of other items (unless allowMultiSelection is
            false). If false, clicking on an item in the outliner will replace the current
            selection with the selected item.
        
        - animLayerFilterOptions : alf   (unicode)       [create,query,edit]
            Specifies whether a filter is to be applied when displaying animation layers. If
            so, the options can be allAffecting(no filter), active(only the active layers on
            the object will be displayed) and animLayerEditor(the settings will be taken
            from the animation layer editor).
        
        - attrAlphaOrder : aao           (unicode)       [create,query,edit]
            Specify how attributes are to be sorted. Current recognised values are
            defaultfor no sorting and ascendto sort attributes from 'a' to ''z' and
            descendto sort from 'z' to 'a'. Notes: a) this only applies to top level
            attributes.
        
        - attrFilter : af                (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be placed on this editor. This
            filters the attributes displayed in the editor.
        
        - autoExpand : xpd               (bool)          [create,query,edit]
            This flag specifies whether or not objects that are loaded in should have their
            attributes automatically expanded.
        
        - autoExpandLayers : ael         (bool)          [create,query,edit]
            If true then when a node with animation layer is displayed, all the animation
            layers will show up in expanded form.
        
        - autoSelectNewObjects : autoSelectNewObjects (bool)          [create,query,edit]
            This flag specifies whether or not new objects added to the outliner should be
            automatically selected.
        
        - containersIgnoreFilters : cif  (bool)          [create,query,edit]
            This flag specifices whether or not filters should be ignored when displaying
            container contents.
        
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - directSelect : ds              (bool)          [create,edit]
            If true then clicking on an item in the outliner will add or remove just that
            item from the selection connection. If false then clicking on an item in the
            outliner causes the selection connection to be reloaded with the currently
            selected items in the outliner.
        
        - displayMode : dm               (unicode)       [create,query,edit]
            Affects how the outliner displays when a filter is applied. List mode is a non-
            indented flat list. DAG mode indents to represent the hierarchical structure of
            the model.
        
        - doNotSelectNewObjects : dns    (bool)          [create,query,edit]
            If true this flag specifies that new objects added to the outliner will not be
            selected, even if they are active.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - dropIsParent : dip             (bool)          [create,query,edit]
            This flag specifies the mode for drag and drop. If the flag is true, dropping
            items will do a reparent. If it is false, dropping will reorder items. By
            default, the flag is true (parent).
        
        - editAttrName : ean             (bool)          [create,query,edit]
            This flag specifies whether or not attribute names can be edited. By default
            double-clicking on an attribute will open the expression editor for that
            attribute.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - expandAllItems : eai           (bool)          [create,edit]
            Expand or collapse all items in the outliner.
        
        - expandAllSelectedItems : eas   (bool)          [create,edit]
            Expand or collapse all selected items in the outliner.
        
        - expandAttribute : att          (bool)          [edit]
            Force the outliner to fill the selection list with only attributes.
        
        - expandConnections : xc         (bool)          [create,query,edit]
            This flag specifies whether or not attributes should be expanded to show their
            input connections. Note: currently the expansion will only show animCurves.
        
        - expandObjects : eo             (bool)          [create,query,edit]
            This flag specifies whether or not objects that are loaded in should be
            automatically expanded.
        
        - feedbackItemName : fbn         (bool)          [query]
            Returns the outliner item name at the current mouse position, if any.
        
        - feedbackRowNumber : fbr        (bool)          [query]
            Returns the outliner row number at the current mouse position, if any.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - getCurrentSetOfItem : gcs      (int)           [query]
            Returns the current set of item at the given row. As an item can belong to
            number of sets, current set is the set to which the item belongs to currently.
        
        - highlightActive : ha           (bool)          [create,query,edit]
            This flag specifies whether or not the outliner should highlight objects that
            are active. Note: if the outliner is driving the contents of another editor,
            setting highlightActive to true may produce unexpected behavior.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - highlightSecondary : hs        (bool)          [create,query,edit]
            This flag specifies whether or not the outliner should highlight objects that
            are contained in the highlightConnection.
        
        - ignoreDagHierarchy : hir       (bool)          [create,query,edit]
            This flag specifies whether or not DAG objects are displayed in their DAG
            hierarchy. Warning: using this flag without some other form of sensible
            filtering will lead to a very confusing outliner.
        
        - ignoreHiddenAttribute : iha    (bool)          [create,query,edit]
            Sets whether or not the outliner ignores the 'hidden in outliner' flag on nodes.
        
        - ignoreOutlinerColor : ioc      (bool)          [create,query,edit]
            Sets whether or not the outliner ignores the 'use outliner color' flag on nodes.
        
        - isChildSelected : ics          (PyNode)        [query]
            This flag allows you to query if one or more of the children of the specified
            item is selected in the outliner. The item should be specified using a unique
            DAG path. Note that if the specified item appears multiple times in the
            outliner, the result will be true if one or more children of any occurrence of
            the specified item in the outliner is/are selected.
        
        - isSet : isSet                  (int)           [query]
            Returns true if the item present at the given row is a set.
        
        - isSetMember : ism              (int)           [query]
            Returns true if the item present at the given row is a set member.
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - longNames : ln                 (bool)          [query,edit]
            Controls whether long or short attribute names will be used in the interface.
            Note that this flag is ignored if the -niceNames flag is set.  Default is short
            names. Queried, returns a boolean.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - mapMotionTrails : mmt          (bool)          [create,query,edit]
            Sets whether or not we replace the motion trail in the outliner with the object
            it is trailing.
        
        - masterOutliner : mst           (unicode)       [create,query,edit]
            This flag is the name of an outliner that this outliner will share the objects
            and state from. When an outliner is shared, all of its state information comes
            from, and is applied to, the master outliner.
        
        - niceNames : nn                 (bool)          [query,edit]
            Controls whether the attribute names will be displayed in a more user-friendly,
            readable way.  When this is on, the longNames flag is ignored.  When this is
            off, attribute names will be displayed either long or short, according to the
            longNames flag. Default is on. Queried, returns a boolean.
        
        - object : obj                   (PyNode)        [query]
            This flags is used together with the parentObjectflag to get the name of the
            parent object for the specified object.
        
        - organizeByClip : obc           (bool)          [create,query,edit]
            If true then when a node with Time Editor clips is displayed, attributes will be
            displayed according to the clip(s) it belongs to. eg:  Clip1 Attr1 Attr2 Clip2
            Attr1  If it is false then the outliner will be organized primarily by
            attributes. eg:  Attr1 Clip1 Clip2 Attr2 Clip1
        
        - organizeByLayer : obl          (bool)          [create,query,edit]
            If true then when a node with animation layer is displayed, attributes will be
            displayed according to the layer(s) it belongs to. eg:  Layer1 Attr1 Attr2
            Layer2 Attr1  If it is false then the outliner will be organized primarily by
            attributes. eg:  Attr1 Layer1 Layer2 Attr2 Layer1
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - parentObject : po              (bool)          [query]
        
        - pinPlug : pin                  (PyNode)        [create,query,edit]
            Pins the named plug, so it always appears in the outliner, irrespective of the
            incoming selection connection. In query mode, returns a list of the pinned
            plugs.
        
        - refresh : rfs                  (bool)          [edit]
            Causes the outliner to refresh itself.
        
        - removeFromCurrentSet : rcs     (int)           [edit]
            Removes selected members of a set from their current set. Current set is the set
            to which item at the given row belongs to. If no selected items, the item at the
            given row is removed from its current set.
        
        - renameItem : rni               (int)           [edit]
            Renames the item at the given row index in the outliner.
        
        - renameSelectedItem : rsi       (bool)          [edit]
            Rename the first selected item in the outliner.
        
        - renderFilterActive : rfa       (bool)          [query]
            This is a query only flag which returns true if the render setup filter is
            Active, i.e one of the four render filters (Inside Selected, Outside Selected,
            Inside All Layers, Outside All Layers) is applied on the outliner currently,
            false otherwise.
        
        - renderFilterIndex : rfi        (int)           [create,query,edit]
            Sets the Render Setup Filter to the index passed. This only works if the filter
            is visible in outliner and its selection is not locked. Valid indices are: 0 -
            Scene2 - Inside Selected3 - Outside Selected4 - Inside All Layers5 - Outside All
            LayersDefault: Scene 0 In query mode returns current index of the filter.
        
        - renderFilterVisible : rfv      (bool)          [create,query,edit]
            Show/Hide the Render Setup Filter in outliner. In query mode returns whether the
            Render Setup Filter is visible or not.
        
        - selectCommand : sec            (script)        [create,query,edit]
            A command to be executed when an item is selected.
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - selectionOrder : sod           (unicode)       [edit]
            Specify how objects are sorted in selection list. Current recognised values are
            chronologicalfor sorting in selection order and displayto sort objects in the
            same order that the outliner does.
        
        - setFilter : sf                 (unicode)       [create,query,edit]
            Specifies the name of a filter which is used to filter which (if any) sets to
            display.
        
        - setsIgnoreFilters : sif        (bool)          [create,query,edit]
            This flag specifies whether or not the filter should be ignored for expanding
            sets to show set members (default is true).
        
        - showAnimCurvesOnly : aco       (bool)          [create,query,edit]
            This flag modifies the showConnected flag.  If showConnected is set to true then
            this flag will cause display of only those attributes that are connected to an
            animCurve. If showConnected is set to false then this flag does nothing.
        
        - showAnimLayerWeight : saw      (bool)          [create,query,edit]
            If true then when a node with animation layer is displayed, the weight of the
            layer will be displayed if it is keyed.
        
        - showAssets : a                 (bool)          [create,query,edit]
            This flags specifies whether assets should be shown in the outliner.
        
        - showAssignedMaterials : sam    (bool)          [create,query,edit]
            Specifies whether to show assigned materials under shapes.
        
        - showAttrValues : av            (bool)          [create,query,edit]
            This flag specifies whether attribute values or attribute names should be
            displayed. Note: currently only string attributes can have their values
            displayed.
        
        - showAttributes : atr           (bool)          [create,query,edit]
            Specifies whether to show attributes or not.
        
        - showCompounds : cmp            (bool)          [create,query,edit]
            This flag specifies whether or not compound attributes should be displayed, or
            just the leaf attributes. Note: if showConnected is true, and the compound
            attribute is connected, it will still be displayed.
        
        - showConnected : con            (bool)          [create,query,edit]
            This flag modifies the showAttributes flag.  If showAttributes is set to true
            then this flag will cause display of only those attributes that are connected in
            the dependency graph. If showAttributes is set to false then this flag does
            nothing.
        
        - showContainedOnly : sco        (bool)          [create,query,edit]
            This flags specifies whether nodes belonging to containers should be show under
            the container node only. Otherwise, it will show up under the world as well.
        
        - showContainerContents : scc    (bool)          [create,query,edit]
            This flags specifies whether the contents of the container should be shown under
            the container node in the outliner.
        
        - showDagOnly : dag              (bool)          [create,query,edit]
            This flag specifies whether all dependency graph objects will be displayed, or
            just DAG objects.
        
        - showLeafs : laf                (bool)          [create,query,edit]
            This flag specifies whether or not leaf attributes should be displayed, or just
            the compound attributes. Note: if showConnected is true, and the leaf attribute
            is connected, it will still be displayed.
        
        - showMuteInfo : smi             (bool)          [create,query,edit]
            This flag specifies whether mute information will be displayed
        
        - showNamespace : sn             (bool)          [create,query,edit]
            This flag specifies whether all objects will have their namespace displayed, if
            namespace different than root.
        
        - showNumericAttrsOnly : num     (bool)          [create,query,edit]
            This flag specifies whether or not all attributes should be displayed, or just
            numeric attributes. Note: if showConnected is true, and the attribute is
            connected, it will still be displayed.
        
        - showParentContainers : spa     (bool)          [create,query,edit]
            This flags specifies whether nodes belonging to containers/assets should show
            their containers/assets as well in its outliner.
        
        - showPinIcons : spi             (bool)          [create,query,edit]
            Sets whether pin icons are shown for unpinned plugs.
        
        - showPublishedAsConnected : spc (bool)          [create,query,edit]
            This flags enables attributes that are published to be displayed in italics.
            Otherwise, only attributes connected as a destination are shown in italics.
        
        - showReferenceMembers : rm      (bool)          [create,query,edit]
            Specifies whether to show reference node members under the reference node in the
            outliner.
        
        - showReferenceNodes : rn        (bool)          [create,query,edit]
            Specifies whether to show reference nodes or not.
        
        - showSelected : sc              (bool)          [create,edit]
            If true then the selected items are expanded in the outliner.
        
        - showSetMembers : ssm           (bool)          [create,query,edit]
            If true then when a set is expanded, the set members will be displayed. If
            false, then only other sets will be displayed.
        
        - showShapes : shp               (bool)          [create,query,edit]
            Specifies whether to show shapes or not.
        
        - showTextureNodesOnly : tno     (bool)          [create,query,edit]
            This flag modifies the showConnected flag. If showConnected is set to true then
            this flag will cause display of only those attributes that are connected to a
            texture node. If showConnected is set to false then this flag does nothing.
        
        - showTimeEditor : ste           (bool)          [create,query,edit]
            If true, all nodes related to the Time Editor will be shown as a hierarchy.
        
        - showUVAttrsOnly : uv           (bool)          [create,query,edit]
            This flag specifies whether or not all attributes should be displayed, or just
            uv attributes. Note: currently the only attribute which will be displayed is
            Shape.uvSet.uvSetName.
        
        - showUnitlessCurves : su        (bool)          [create,query,edit]
            This flag (in combination with -expandConnections) specifies whether or not
            connection expansion should show unitless animCurves.
        
        - showUpstreamCurves : suc       (bool)          [create,query,edit]
            Specifies exactly which attributes are displayed when showAttributes and
            expandConnections are both true. If true, the dependency graph is searched
            upstream for all curves that drive the selected plugs (showing multiple curves
            for example in a typical driven key setup, where first the driven key curve is
            encountered, followed by the actual animation curve that drives the source
            object). If false, only the first curves encountered will be shown. Note that,
            even if false, multiple curves can be shown if e.g. a blendWeighted node is
            being used to combine multiple curves.
        
        - sortCommand : soc              (callable)      []
        
        - sortOrder : so                 (unicode)       [create,query,edit]
            Specify how objects are to be sorted.  Current recognised values are nonefor no
            sorting and dagNameto sort DAG objects by name. Notes: a) non-DAG objects are
            always sorted by nodeType and name. b) when sortOrder is set to dagName, objects
            cannot be reordered using drag-and-drop, they can however be reparented.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - transmitFilters : tf           (bool)          [create,query,edit]
            This flag specifies how the selectionConnection is populated when attribute
            filters are enabled.  If this flag is set to true, then all the attributes that
            pass the filter will be placed on the selectionConnection.  By default this flag
            is false.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - unpinPlug : unp                (PyNode)        [create,edit]
            Unpins the named plug.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.outlinerEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'outlinerEditor'
    
    
    __melui__ = 'outlinerEditor'


class RadioButton(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the radio button's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the radio button from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getAlign(self, **kwargs):
        """
        This flag is obsolete and should no longer be used. The radio button label will always be left-aligned.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getData(self, **kwargs):
        """
        Internal data associated with the radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the radio button.  By default, this flag is set to true and the radio button value may be changed by clicking on it.  If false then the radio button is 'read only' and can not be clicked on. The value of the radio button can always be changed with the -sl/selectflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The label text.  The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getRecomputeSize(self, **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Select the radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def offCommand(self, val='True', **kwargs):
        """
        Command executed when the radio button is turned off.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def onCommand(self, val='True', **kwargs):
        """
        Command executed when the radio button is turned on.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        This flag is obsolete and should no longer be used. The radio button label will always be left-aligned.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setData(self, val='True', **kwargs):
        """
        Internal data associated with the radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the radio button.  By default, this flag is set to true and the radio button value may be changed by clicking on it.  If false then the radio button is 'read only' and can not be clicked on. The value of the radio button can always be changed with the -sl/selectflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The label text.  The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setRecomputeSize(self, val='True', **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Select the radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a radio button that is added to the most recently created
        radio collection if the -cl/collectionflag is not used.
        
        Flags:
        - align : al                     (unicode)       [create,query,edit]
            This flag is obsolete and should no longer be used. The radio button label will
            always be left-aligned.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the radio button's state is changed. Note that this flag
            should not be used in conjunction with onCommand and offCommand. That is, one
            should either use changeCommand and test the state of the radio button from
            inside the callback, or use onCommand and offCommand as separate callbacks.
        
        - collection : cl                (unicode)       [create]
            To explicitly add a radio button to a collection of radio buttons specify the
            name of the radio collection.
        
        - data : da                      (int)           [create,query,edit]
            Internal data associated with the radio button.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the radio button.  By default, this flag is set to true and
            the radio button value may be changed by clicking on it.  If false then the
            radio button is 'read only' and can not be clicked on. The value of the radio
            button can always be changed with the -sl/selectflag regardless of the state of
            the -ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The label text.  The default label is the name of the control.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - offCommand : ofc               (script)        [create,edit]
            Command executed when the radio button is turned off.
        
        - onCommand : onc                (script)        [create,edit]
            Command executed when the radio button is turned on.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - recomputeSize : rs             (bool)          [create,query,edit]
            If true then the control will recompute it's size to just fit the size of the
            label.  If false then the control size will remain fixed as you change the size
            of the label.  The default value of this flag is true.
        
        - select : sl                    (bool)          [create,query,edit]
            Select the radio button.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.radioButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'radioButton'
    
    
    __melui__ = 'radioButton'


class DynRelEditor(PyUI):
    __melui__ = 'dynRelEditor'


class RenderWindowEditor(PyUI):
    def colorManage(self, val='True', **kwargs):
        """
        When used with the writeImage flag, causes the written image to be color-managed using the settings from the view color manager attached to the view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getAutoResize(self, **kwargs):
        """
        Lets the render view editor automatically resize the viewport or not.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getBlendMode(self, **kwargs):
        """
        Sets the blend mode for the render view. New image sent to the render view will be blended with the previous image in the render view, and the composited image will appear.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getCaption(self, **kwargs):
        """
        Sets the caption which appears at the bottom of the render view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getChangeCommand(self, **kwargs):
        """
        Parameters: First string: commandSecond string: editorNameThird string: editorCmdFourth string: updateFuncCall the command when something changes in the editor The command should have this prototype :  command(string $editor, string $editorCmd, string $updateFunc, int $reason)  The possible reasons could be : 0: no particular reason1: scale color2: buffer (single/double)3: axis 4: image displayed5: image saved in memory
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getClear(self, **kwargs):
        """
        Clear the image with the given color at the given resolution. Argumnets are respecively: width height red green blue.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getCmEnabled(self, **kwargs):
        """
        Turn on or off applying color management in the View.  If set, the color management configuration set in the current view is used.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getCompDisplay(self, **kwargs):
        """
        0 : disable compositing.1 : displays the composited image immediately. For example, when foreground layer tile is sent to the render view window, the composited tile is displayed in the render view window, and the original foreground layer tile is not displayed.2 : display the un-composited image, and keep the composited image for the future command. For example, when foreground layer tile is sent to the render view window, the original foreground layer tile is not displayed, and the composited tile is stored in a buffer.3 : show the current composited image. If there is a composited image in the buffer, display it.
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getCompImageFile(self, **kwargs):
        """
        Open the given image file and blend with the buffer as if the image was just rendered.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getCurrentCamera(self, **kwargs):
        """
        Get or set the current camera. (used when redoing last render)                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getCurrentCameraRig(self, **kwargs):
        """
        Get or set the current camera rig name. If a camera rig is specified, it will be used when redoing the last render as opposed to the currentCamera value, as the currentCamera value will hold the child camera last used for rendering the camera rig.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getDisplayImage(self, **kwargs):
        """
        Set a particular image in the Editor Image Stack as the current Editor Image. Images are added to the Editor Image Stack using the si/saveImageflag.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getDisplayImageViewCount(self, **kwargs):
        """
        Query the number of views stored for a given image in the Editor Image Stack. This is not the same as querying using viewImageCountwhich returns the number of views for the current rendered image.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getDisplayStyle(self, **kwargs):
        """
        Set the mode to display the image. Valid values are: colorto display the basic RGB imagemaskto display the mask channellumto display the luminance of the image
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getDoubleBuffer(self, **kwargs):
        """
        Set the display in double buffer mode                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getDrawAxis(self, **kwargs):
        """
        Set or query whether the axis will be drawn.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getEditorName(self, **kwargs):
        """
        Returns the name of the editor, or an empty string if the editor has not been created yet.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getExposure(self, **kwargs):
        """
        The exposure value used by the color management of the current view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getFrameImage(self, **kwargs):
        """
        Frames the image inside the window.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getFrameRegion(self, **kwargs):
        """
        Frames the region inside the window.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getGamma(self, **kwargs):
        """
        The gamma value used by the color management of the current view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getMarquee(self, **kwargs):
        """
        The arguments define the four corners of a rectangle: top left bottom right. The rectangle defines a marquee for the render computation.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getNbImages(self, **kwargs):
        """
        returns the number of images                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getPcaption(self, **kwargs):
        """
        Get or set the permanent caption which appears under the image that is currently showing in the render editor.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getRealSize(self, **kwargs):
        """
        Display the image with a one to one pixel match.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getResetRegion(self, **kwargs):
        """
        Forces a reset of any marquee/region.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getScaleBlue(self, **kwargs):
        """
        Define the scaling factor for the blue component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getScaleGreen(self, **kwargs):
        """
        Define the scaling factor for the green component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getScaleRed(self, **kwargs):
        """
        Define the scaling factor for the red component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getShowRegion(self, **kwargs):
        """
        Shows the current region at the given resolution. The two parameters define the width and height.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getSingleBuffer(self, **kwargs):
        """
        Set the display in single buffer mode                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getSnapshot(self, **kwargs):
        """
        Makes a copy of the camera of the model editor at the given size. First argument is the editor name, second is the width, third is the height.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getSnapshotMode(self, **kwargs):
        """
        Get or set the window's snapshot mode.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getStereo(self, **kwargs):
        """
        Puts the editor into stereo image mode.  The effective resolution of the output image is twice the size of the horizontal size. The orientation of the images can be set using the stereoOrientation flag.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getStereoImageOrientation(self, **kwargs):
        """
        Specifies the orientation of stereo camera renders.  The first argument specifies the orientation value for the firstleft image and the second argument specifies the orientation value for the right image. The orientation values are 'normal', the image appears as seen throught he camera, or 'mirrored', the image is mirrored horizontally.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getStereoMode(self, **kwargs):
        """
        Specifies how the image is displayed in the view.  By default the stereo is rendered with a side by side image.  The rendered image is a single image that is twice the size of a normal image, 'both'. Users can also choose to display as 'redcyan', 'redcyanlum', 'leftonly', 'rightonly', or 'stereo'.  both - displays both the left and right redcyan - displays the images as a red/cyan pair. redcyanlum - displays the luminance of the images as a red/cyan pair. leftonly - displays the left side only rightonly - displays the right side only stereo - mode that supports Crystal Eyes(tm) or Zscreen (tm) renders                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getToggle(self, **kwargs):
        """
        Turns the ground plane display on/off.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getViewImageCount(self, **kwargs):
        """
        The render editor has the capability to render multiple cameras within a single view. This is different from image binning where an image is saved. Multiple image views are useful for comparing two different camera renders side-by-side. The viewImageCount flag tells the editor that it should prepare its internal image storage mechanism for a given number of views.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def getViewTransformName(self, **kwargs):
        """
        Sets/gets the view transform to be applied if color management is enabled in the current view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def loadImage(self, val='True', **kwargs):
        """
        load an image from disk and set it as the current Editor Image                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def nextViewImage(self, val='True', **kwargs):
        """
        The render editor has the capability to render multiple cameras within a single view. This is different from image binning where an image is saved. Multiple image views are useful for comparing two different camera renders side-by-side. The nextViewImage flag tells the editor that it should prepare its internal image storage mechanism to store to the next view location.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def outputColorManage(self, val='True', **kwargs):
        """
        When used with the writeImage flag, causes the written image to be color-managed using the outpute color space in the color preferences attached to the view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def refresh(self, val='True', **kwargs):
        """
        requests a refresh of the current Editor Image.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def removeAllImages(self, val='True', **kwargs):
        """
        remove all the Editor Images from the Editor Image Stack                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def removeImage(self, val='True', **kwargs):
        """
        remove the current Editor Image from the Editor Image Stack                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def resetViewImage(self, val='True', **kwargs):
        """
        The render editor has the capability to render multiple cameras within a single view. This is different from image binning where an image is saved. Multiple image views are useful for comparing two different camera renders side-by-side. The resetViewImage flag tells the editor that it should reset its internal image storage mechanism to the first image. This would happen at the very start of a render view render.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def saveImage(self, val='True', **kwargs):
        """
        save the current Editor Image to memory. Saved Editor Images are stored in an Editor Image Stack. The most recently saved image is stored in position 0, the second most recently saved image in position 1, and so on... To set the current Editor Image to a previously saved image use the di/displayImageflag.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setAutoResize(self, val='True', **kwargs):
        """
        Lets the render view editor automatically resize the viewport or not.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setBlendMode(self, val='True', **kwargs):
        """
        Sets the blend mode for the render view. New image sent to the render view will be blended with the previous image in the render view, and the composited image will appear.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setCaption(self, val='True', **kwargs):
        """
        Sets the caption which appears at the bottom of the render view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setChangeCommand(self, val='True', **kwargs):
        """
        Parameters: First string: commandSecond string: editorNameThird string: editorCmdFourth string: updateFuncCall the command when something changes in the editor The command should have this prototype :  command(string $editor, string $editorCmd, string $updateFunc, int $reason)  The possible reasons could be : 0: no particular reason1: scale color2: buffer (single/double)3: axis 4: image displayed5: image saved in memory
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setClear(self, val='True', **kwargs):
        """
        Clear the image with the given color at the given resolution. Argumnets are respecively: width height red green blue.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setCmEnabled(self, val='True', **kwargs):
        """
        Turn on or off applying color management in the View.  If set, the color management configuration set in the current view is used.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setCompDisplay(self, val='True', **kwargs):
        """
        0 : disable compositing.1 : displays the composited image immediately. For example, when foreground layer tile is sent to the render view window, the composited tile is displayed in the render view window, and the original foreground layer tile is not displayed.2 : display the un-composited image, and keep the composited image for the future command. For example, when foreground layer tile is sent to the render view window, the original foreground layer tile is not displayed, and the composited tile is stored in a buffer.3 : show the current composited image. If there is a composited image in the buffer, display it.
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setCompImageFile(self, val='True', **kwargs):
        """
        Open the given image file and blend with the buffer as if the image was just rendered.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setCurrentCamera(self, val='True', **kwargs):
        """
        Get or set the current camera. (used when redoing last render)                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setCurrentCameraRig(self, val='True', **kwargs):
        """
        Get or set the current camera rig name. If a camera rig is specified, it will be used when redoing the last render as opposed to the currentCamera value, as the currentCamera value will hold the child camera last used for rendering the camera rig.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setDisplayImage(self, val='True', **kwargs):
        """
        Set a particular image in the Editor Image Stack as the current Editor Image. Images are added to the Editor Image Stack using the si/saveImageflag.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setDisplayStyle(self, val='True', **kwargs):
        """
        Set the mode to display the image. Valid values are: colorto display the basic RGB imagemaskto display the mask channellumto display the luminance of the image
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setDoubleBuffer(self, val='True', **kwargs):
        """
        Set the display in double buffer mode                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setDrawAxis(self, val='True', **kwargs):
        """
        Set or query whether the axis will be drawn.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setExposure(self, val='True', **kwargs):
        """
        The exposure value used by the color management of the current view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setFrameImage(self, val='True', **kwargs):
        """
        Frames the image inside the window.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setFrameRegion(self, val='True', **kwargs):
        """
        Frames the region inside the window.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setGamma(self, val='True', **kwargs):
        """
        The gamma value used by the color management of the current view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setMarquee(self, val='True', **kwargs):
        """
        The arguments define the four corners of a rectangle: top left bottom right. The rectangle defines a marquee for the render computation.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setPcaption(self, val='True', **kwargs):
        """
        Get or set the permanent caption which appears under the image that is currently showing in the render editor.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setRealSize(self, val='True', **kwargs):
        """
        Display the image with a one to one pixel match.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setResetRegion(self, val='True', **kwargs):
        """
        Forces a reset of any marquee/region.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setScaleBlue(self, val='True', **kwargs):
        """
        Define the scaling factor for the blue component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setScaleGreen(self, val='True', **kwargs):
        """
        Define the scaling factor for the green component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setScaleRed(self, val='True', **kwargs):
        """
        Define the scaling factor for the red component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setShowRegion(self, val='True', **kwargs):
        """
        Shows the current region at the given resolution. The two parameters define the width and height.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setSingleBuffer(self, val='True', **kwargs):
        """
        Set the display in single buffer mode                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setSnapshot(self, val='True', **kwargs):
        """
        Makes a copy of the camera of the model editor at the given size. First argument is the editor name, second is the width, third is the height.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setSnapshotMode(self, val='True', **kwargs):
        """
        Get or set the window's snapshot mode.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setStereo(self, val='True', **kwargs):
        """
        Puts the editor into stereo image mode.  The effective resolution of the output image is twice the size of the horizontal size. The orientation of the images can be set using the stereoOrientation flag.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setStereoImageOrientation(self, val='True', **kwargs):
        """
        Specifies the orientation of stereo camera renders.  The first argument specifies the orientation value for the firstleft image and the second argument specifies the orientation value for the right image. The orientation values are 'normal', the image appears as seen throught he camera, or 'mirrored', the image is mirrored horizontally.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setStereoMode(self, val='True', **kwargs):
        """
        Specifies how the image is displayed in the view.  By default the stereo is rendered with a side by side image.  The rendered image is a single image that is twice the size of a normal image, 'both'. Users can also choose to display as 'redcyan', 'redcyanlum', 'leftonly', 'rightonly', or 'stereo'.  both - displays both the left and right redcyan - displays the images as a red/cyan pair. redcyanlum - displays the luminance of the images as a red/cyan pair. leftonly - displays the left side only rightonly - displays the right side only stereo - mode that supports Crystal Eyes(tm) or Zscreen (tm) renders                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setToggle(self, val='True', **kwargs):
        """
        Turns the ground plane display on/off.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setViewImageCount(self, val='True', **kwargs):
        """
        The render editor has the capability to render multiple cameras within a single view. This is different from image binning where an image is saved. Multiple image views are useful for comparing two different camera renders side-by-side. The viewImageCount flag tells the editor that it should prepare its internal image storage mechanism for a given number of views.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def setViewTransformName(self, val='True', **kwargs):
        """
        Sets/gets the view transform to be applied if color management is enabled in the current view.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    def writeImage(self, val='True', **kwargs):
        """
        write the current Editor Image to disk                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a editor window that can receive the result of the rendering process
        
        Flags:
        - autoResize : ar                (bool)          [create,query,edit]
            Lets the render view editor automatically resize the viewport or not.
        
        - blendMode : blm                (int)           [create,query,edit]
            Sets the blend mode for the render view. New image sent to the render view will
            be blended with the previous image in the render view, and the composited image
            will appear.
        
        - caption : cap                  (unicode)       [create,query,edit]
            Sets the caption which appears at the bottom of the render view.
        
        - changeCommand : cc             (unicode, unicode, unicode, unicode) [create,query,edit]
            Parameters: First string: commandSecond string: editorNameThird string:
            editorCmdFourth string: updateFuncCall the command when something changes in the
            editor The command should have this prototype :  command(string $editor, string
            $editorCmd, string $updateFunc, int $reason)  The possible reasons could be : 0:
            no particular reason1: scale color2: buffer (single/double)3: axis 4: image
            displayed5: image saved in memory
        
        - clear : cl                     (int, int, float, float, float) [create,query,edit]
            Clear the image with the given color at the given resolution. Argumnets are
            respecively: width height red green blue.
        
        - cmEnabled : cme                (bool)          [query,edit]
            Turn on or off applying color management in the View.  If set, the color
            management configuration set in the current view is used.
        
        - colorManage : com              (bool)          [edit]
            When used with the writeImage flag, causes the written image to be color-managed
            using the settings from the view color manager attached to the view.
        
        - compDisplay : cd               (int)           [create,query,edit]
            0 : disable compositing.1 : displays the composited image immediately. For
            example, when foreground layer tile is sent to the render view window, the
            composited tile is displayed in the render view window, and the original
            foreground layer tile is not displayed.2 : display the un-composited image, and
            keep the composited image for the future command. For example, when foreground
            layer tile is sent to the render view window, the original foreground layer tile
            is not displayed, and the composited tile is stored in a buffer.3 : show the
            current composited image. If there is a composited image in the buffer, display
            it.
        
        - compImageFile : cif            (unicode)       [create,query,edit]
            Open the given image file and blend with the buffer as if the image was just
            rendered.
        
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - currentCamera : crc            (unicode)       [create,query,edit]
            Get or set the current camera. (used when redoing last render)
        
        - currentCameraRig : crg         (unicode)       [create,query,edit]
            Get or set the current camera rig name. If a camera rig is specified, it will be
            used when redoing the last render as opposed to the currentCamera value, as the
            currentCamera value will hold the child camera last used for rendering the
            camera rig.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - displayImage : di              (int)           [query,edit]
            Set a particular image in the Editor Image Stack as the current Editor Image.
            Images are added to the Editor Image Stack using the si/saveImageflag.
        
        - displayImageViewCount : dvc    (int)           [query]
            Query the number of views stored for a given image in the Editor Image Stack.
            This is not the same as querying using viewImageCountwhich returns the number of
            views for the current rendered image.
        
        - displayStyle : dst             (unicode)       [create,query,edit]
            Set the mode to display the image. Valid values are: colorto display the basic
            RGB imagemaskto display the mask channellumto display the luminance of the image
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - doubleBuffer : dbf             (bool)          [create,query,edit]
            Set the display in double buffer mode
        
        - drawAxis : da                  (bool)          [create,query,edit]
            Set or query whether the axis will be drawn.
        
        - editorName : en                (bool)          [query]
            Returns the name of the editor, or an empty string if the editor has not been
            created yet.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - exposure : exp                 (float)         [query,edit]
            The exposure value used by the color management of the current view.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - frameImage : fi                (bool)          [create,query,edit]
            Frames the image inside the window.
        
        - frameRegion : fr               (bool)          [create,query,edit]
            Frames the region inside the window.
        
        - gamma : ga                     (float)         [query,edit]
            The gamma value used by the color management of the current view.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - loadImage : li                 (unicode)       [edit]
            load an image from disk and set it as the current Editor Image
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - marquee : mq                   (float, float, float, float) [create,query,edit]
            The arguments define the four corners of a rectangle: top left bottom right. The
            rectangle defines a marquee for the render computation.
        
        - nbImages : nim                 (bool)          [query]
            returns the number of images
        
        - nextViewImage : nvi            (bool)          [create,edit]
            The render editor has the capability to render multiple cameras within a single
            view. This is different from image binning where an image is saved. Multiple
            image views are useful for comparing two different camera renders side-by-side.
            The nextViewImage flag tells the editor that it should prepare its internal
            image storage mechanism to store to the next view location.
        
        - outputColorManage : ocm        (bool)          [edit]
            When used with the writeImage flag, causes the written image to be color-managed
            using the outpute color space in the color preferences attached to the view.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - pcaption : pca                 (unicode)       [create,query,edit]
            Get or set the permanent caption which appears under the image that is currently
            showing in the render editor.
        
        - realSize : rs                  (bool)          [create,query,edit]
            Display the image with a one to one pixel match.
        
        - refresh : ref                  (bool)          [edit]
            requests a refresh of the current Editor Image.
        
        - removeAllImages : ra           (bool)          [edit]
            remove all the Editor Images from the Editor Image Stack
        
        - removeImage : ri               (bool)          [edit]
            remove the current Editor Image from the Editor Image Stack
        
        - resetRegion : rr               (bool)          [create,query,edit]
            Forces a reset of any marquee/region.
        
        - resetViewImage : rvi           (bool)          [create,edit]
            The render editor has the capability to render multiple cameras within a single
            view. This is different from image binning where an image is saved. Multiple
            image views are useful for comparing two different camera renders side-by-side.
            The resetViewImage flag tells the editor that it should reset its internal image
            storage mechanism to the first image. This would happen at the very start of a
            render view render.
        
        - saveImage : si                 (bool)          [edit]
            save the current Editor Image to memory. Saved Editor Images are stored in an
            Editor Image Stack. The most recently saved image is stored in position 0, the
            second most recently saved image in position 1, and so on... To set the current
            Editor Image to a previously saved image use the di/displayImageflag.
        
        - scaleBlue : sb                 (float)         [create,query,edit]
            Define the scaling factor for the blue component in the View. The default value
            is 1 and can be between -1000 to +1000
        
        - scaleGreen : sg                (float)         [create,query,edit]
            Define the scaling factor for the green component in the View. The default value
            is 1 and can be between -1000 to +1000
        
        - scaleRed : sr                  (float)         [create,query,edit]
            Define the scaling factor for the red component in the View. The default value
            is 1 and can be between -1000 to +1000
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - showRegion : srg               (int, int)      [create,query,edit]
            Shows the current region at the given resolution. The two parameters define the
            width and height.
        
        - singleBuffer : sbf             (bool)          [create,query,edit]
            Set the display in single buffer mode
        
        - snapshot : snp                 (unicode, int, int) [create,query,edit]
            Makes a copy of the camera of the model editor at the given size. First argument
            is the editor name, second is the width, third is the height.
        
        - snapshotMode : snm             (bool)          [create,query,edit]
            Get or set the window's snapshot mode.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - stereo : s                     (int)           [create,query,edit]
            Puts the editor into stereo image mode.  The effective resolution of the output
            image is twice the size of the horizontal size. The orientation of the images
            can be set using the stereoOrientation flag.
        
        - stereoImageOrientation : sio   (unicode, unicode) [create,query,edit]
            Specifies the orientation of stereo camera renders.  The first argument
            specifies the orientation value for the firstleft image and the second argument
            specifies the orientation value for the right image. The orientation values are
            'normal', the image appears as seen throught he camera, or 'mirrored', the image
            is mirrored horizontally.
        
        - stereoMode : sm                (unicode)       [create,query,edit]
            Specifies how the image is displayed in the view.  By default the stereo is
            rendered with a side by side image.  The rendered image is a single image that
            is twice the size of a normal image, 'both'. Users can also choose to display as
            'redcyan', 'redcyanlum', 'leftonly', 'rightonly', or 'stereo'.  both - displays
            both the left and right redcyan - displays the images as a red/cyan pair.
            redcyanlum - displays the luminance of the images as a red/cyan pair. leftonly -
            displays the left side only rightonly - displays the right side only stereo -
            mode that supports Crystal Eyes(tm) or Zscreen (tm) renders
        
        - toggle : tgl                   (bool)          [create,query,edit]
            Turns the ground plane display on/off.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - viewImageCount : vic           (int)           [create,query,edit]
            The render editor has the capability to render multiple cameras within a single
            view. This is different from image binning where an image is saved. Multiple
            image views are useful for comparing two different camera renders side-by-side.
            The viewImageCount flag tells the editor that it should prepare its internal
            image storage mechanism for a given number of views.
        
        - viewTransformName : vtn        (unicode)       [query,edit]
            Sets/gets the view transform to be applied if color management is enabled in the
            current view.
        
        - writeImage : wi                (unicode)       [edit]
            write the current Editor Image to disk                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.renderWindowEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'renderWindowEditor'
    
    
    __melui__ = 'renderWindowEditor'


class DynPaintEditor(PyUI):
    def canvasUndo(self, val='True', **kwargs):
        """
        Does a fast undo in Canvas mode. This is a special undo because we are not using any history when we paint in Canvas mode so we provide a single level undo for the Canvas.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def clear(self, val='True', **kwargs):
        """
        Clears the buffer (if in Canvas mode) to the floating point values (R,G,B).                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getActiveOnly(self, **kwargs):
        """
        For Scene mode, this determines if only the active strokes will be refreshed.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getAutoSave(self, **kwargs):
        """
        For Canvas mode, this determines if the buffer will be saved to a disk file after every stroke. Good for painting textures and viewing the results in shaded display in the model view.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getCamera(self, **kwargs):
        """
        Sets the name of the camera which the Paint Effects panel looks through.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getCanvasMode(self, **kwargs):
        """
        Sets the Paint Effects panel into Canvas mode if true.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getChangeCommand(self, **kwargs):
        """
        Parameters: First string: commandSecond string: editorNameThird string: editorCmdFourth string: updateFuncCall the command when something changes in the editor The command should have this prototype :  command(string $editor, string $editorCmd, string $updateFunc, int $reason)  The possible reasons could be : 0: no particular reason1: scale color2: buffer (single/double)3: axis 4: image displayed5: image saved in memory
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getControl(self, **kwargs):
        """
        Query only. Returns the top level control for this editor. Usually used for getting a parent to attach popup menus. Caution: It is possible for an editor to exist without a control. The query will return NONEif no control is present.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getCurrentCanvasSize(self, **kwargs):
        """
        In Query mode, this returns the (X,Y) resolution of the current canvas.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDisplayAppearance(self, **kwargs):
        """
        Sets the display appearance of the model panel.  Possible values are wireframe, points, boundingBox, smoothShaded, flatShaded.  This flag may be used with the -interactive and -default flags.  Note that only wireframe, points, and boundingBoxare valid for the interactive mode.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDisplayFog(self, **kwargs):
        """
        For Scene mode, this determines if fog will be displayed in the Paint Effects panel when refreshing the scene. If fog is on, but this is off, fog will only be drawn on the strokes, not the rest of the scene.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDisplayImage(self, **kwargs):
        """
        Set a particular image in the Editor Image Stack as the current Editor Image. Images are added to the Editor Image Stack using the si/saveImageflag.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDisplayLights(self, **kwargs):
        """
        Sets the lighting for shaded mode.  Possible values are selected, active, all, default.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDisplayStyle(self, **kwargs):
        """
        Set the mode to display the image. Valid values are: colorto display the basic RGB imagemaskto display the mask channellumto display the luminance of the image
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDisplayTextures(self, **kwargs):
        """
        Turns on or off display of textures in shaded mode                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDoubleBuffer(self, **kwargs):
        """
        Set the display in double buffer mode                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDrawAxis(self, **kwargs):
        """
        Set or query whether the axis will be drawn.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getDrawContext(self, **kwargs):
        """
        Returns the name of the context.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getFileName(self, **kwargs):
        """
        This sets the file to which the canvas will be saved.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getFilter(self, **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getForceMainConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getHighlightConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getMainListConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getNbImages(self, **kwargs):
        """
        returns the number of images                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getNewImage(self, **kwargs):
        """
        Starts a new image in edit mode, setting the resolution to the integer values (X,Y) and clearing the buffer to the floating point values (R,G,B). In Query mode, this returns the (X,Y) resolution of the current Image.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getPanel(self, **kwargs):
        """
        Specifies the panel for this editor. By default if an editor is created in the create callback of a scripted panel it will belong to that panel. If an editor does not belong to a panel it will be deleted when the window that it is in is deleted.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getRefreshMode(self, **kwargs):
        """
        Sets the refresh mode to the specified value. 0 - Do not draw strokes on refresh, 1 - Redraw strokes in wireframe mode, 2 - Redraw strokes in final rendered mode.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getSaveAlpha(self, **kwargs):
        """
        For Canvas mode, this determines if the alpha will be saved when storing the canvas to a disk file.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getSaveBumpmap(self, **kwargs):
        """
        Saves the current buffer as a bump map to the specified file.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getScaleBlue(self, **kwargs):
        """
        Define the scaling factor for the blue component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getScaleGreen(self, **kwargs):
        """
        Define the scaling factor for the green component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getScaleRed(self, **kwargs):
        """
        Define the scaling factor for the red component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getSelectionConnection(self, **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getSingleBuffer(self, **kwargs):
        """
        Set the display in single buffer mode                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getStateString(self, **kwargs):
        """
        Query only flag. Returns the MEL command that will create an editor to match the current editor state. The returned command string uses the string variable $editorName in place of a specific name.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getWrap(self, **kwargs):
        """
        For Canvas mode, should the buffer wrap in U, and V (respectively) when painting.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def getZoom(self, **kwargs):
        """
        Zooms the Canvas image by the specified value.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def iconGrab(self, val='True', **kwargs):
        """
        This puts the Paint Effects panel into Grab Icon mode where the user is expected to drag out a section of the screen to be made into an icon.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def loadImage(self, val='True', **kwargs):
        """
        load an image from disk and set it as the current Editor Image                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def lockMainConnection(self, val='True', **kwargs):
        """
        Locks the current list of objects within the mainConnection, so that only those objects are displayed within the editor. Further changes to the original mainConnection are ignored.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def paintAll(self, val='True', **kwargs):
        """
        Redraws the buffer in current refresh mode.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def redrawLast(self, val='True', **kwargs):
        """
        Redraws the last stroke again. Useful when it's brush has just changed. This feature does a fast undo and redraws the stroke again.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def refresh(self, val='True', **kwargs):
        """
        requests a refresh of the current Editor Image.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def removeAllImages(self, val='True', **kwargs):
        """
        remove all the Editor Images from the Editor Image Stack                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def removeImage(self, val='True', **kwargs):
        """
        remove the current Editor Image from the Editor Image Stack                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def rollImage(self, val='True', **kwargs):
        """
        In Canvas mode, this rolls the image by the floating point values (X,Y). X and Y are between 0 (no roll) and 1 (full roll). A value of .5 rolls the image 50% (ie. the border moves to the center of the screen.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def saveImage(self, val='True', **kwargs):
        """
        save the current Editor Image to memory. Saved Editor Images are stored in an Editor Image Stack. The most recently saved image is stored in position 0, the second most recently saved image in position 1, and so on... To set the current Editor Image to a previously saved image use the di/displayImageflag.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setActiveOnly(self, val='True', **kwargs):
        """
        For Scene mode, this determines if only the active strokes will be refreshed.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setAutoSave(self, val='True', **kwargs):
        """
        For Canvas mode, this determines if the buffer will be saved to a disk file after every stroke. Good for painting textures and viewing the results in shaded display in the model view.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setCamera(self, val='True', **kwargs):
        """
        Sets the name of the camera which the Paint Effects panel looks through.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setCanvasMode(self, val='True', **kwargs):
        """
        Sets the Paint Effects panel into Canvas mode if true.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setChangeCommand(self, val='True', **kwargs):
        """
        Parameters: First string: commandSecond string: editorNameThird string: editorCmdFourth string: updateFuncCall the command when something changes in the editor The command should have this prototype :  command(string $editor, string $editorCmd, string $updateFunc, int $reason)  The possible reasons could be : 0: no particular reason1: scale color2: buffer (single/double)3: axis 4: image displayed5: image saved in memory
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDisplayAppearance(self, val='True', **kwargs):
        """
        Sets the display appearance of the model panel.  Possible values are wireframe, points, boundingBox, smoothShaded, flatShaded.  This flag may be used with the -interactive and -default flags.  Note that only wireframe, points, and boundingBoxare valid for the interactive mode.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDisplayFog(self, val='True', **kwargs):
        """
        For Scene mode, this determines if fog will be displayed in the Paint Effects panel when refreshing the scene. If fog is on, but this is off, fog will only be drawn on the strokes, not the rest of the scene.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDisplayImage(self, val='True', **kwargs):
        """
        Set a particular image in the Editor Image Stack as the current Editor Image. Images are added to the Editor Image Stack using the si/saveImageflag.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDisplayLights(self, val='True', **kwargs):
        """
        Sets the lighting for shaded mode.  Possible values are selected, active, all, default.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDisplayStyle(self, val='True', **kwargs):
        """
        Set the mode to display the image. Valid values are: colorto display the basic RGB imagemaskto display the mask channellumto display the luminance of the image
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDisplayTextures(self, val='True', **kwargs):
        """
        Turns on or off display of textures in shaded mode                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the editor.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDoubleBuffer(self, val='True', **kwargs):
        """
        Set the display in double buffer mode                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setDrawAxis(self, val='True', **kwargs):
        """
        Set or query whether the axis will be drawn.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setFileName(self, val='True', **kwargs):
        """
        This sets the file to which the canvas will be saved.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setFilter(self, val='True', **kwargs):
        """
        Specifies the name of an itemFilter object to be used with this editor. This filters the information coming onto the main list of the editor.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setForceMainConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object. This is a variant of the -mainListConnection flag in that it will force a change even when the connection is locked. This flag is used to reduce the overhead when using the -unlockMainConnection , -mainListConnection, -lockMainConnection flags in immediate succession.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setHighlightConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its highlight list. Not all editors have a highlight list. For those that do, it is a secondary selection list.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setMainListConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will use as its source of content. The editor will only display items contained in the selectionConnection object.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setNewImage(self, val='True', **kwargs):
        """
        Starts a new image in edit mode, setting the resolution to the integer values (X,Y) and clearing the buffer to the floating point values (R,G,B). In Query mode, this returns the (X,Y) resolution of the current Image.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setParent(self, val='True', **kwargs):
        """
        Specifies the parent layout for this editor. This flag will only have an effect if the editor is currently un-parented.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setRefreshMode(self, val='True', **kwargs):
        """
        Sets the refresh mode to the specified value. 0 - Do not draw strokes on refresh, 1 - Redraw strokes in wireframe mode, 2 - Redraw strokes in final rendered mode.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setSaveAlpha(self, val='True', **kwargs):
        """
        For Canvas mode, this determines if the alpha will be saved when storing the canvas to a disk file.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setSaveBumpmap(self, val='True', **kwargs):
        """
        Saves the current buffer as a bump map to the specified file.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setScaleBlue(self, val='True', **kwargs):
        """
        Define the scaling factor for the blue component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setScaleGreen(self, val='True', **kwargs):
        """
        Define the scaling factor for the green component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setScaleRed(self, val='True', **kwargs):
        """
        Define the scaling factor for the red component in the View. The default value is 1 and can be between -1000 to +1000                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setSelectionConnection(self, val='True', **kwargs):
        """
        Specifies the name of a selectionConnection object that the editor will synchronize with its own selection list. As the user selects things in this editor, they will be selected in the selectionConnection object. If the object undergoes changes, the editor updates to show the changes.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setSingleBuffer(self, val='True', **kwargs):
        """
        Set the display in single buffer mode                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setWrap(self, val='True', **kwargs):
        """
        For Canvas mode, should the buffer wrap in U, and V (respectively) when painting.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def setZoom(self, val='True', **kwargs):
        """
        Zooms the Canvas image by the specified value.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def snapShot(self, val='True', **kwargs):
        """
        Takes a snapshot of the current camera view.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def tileSize(self, val='True', **kwargs):
        """
        Sets the size of the tile for the hardware texture redraw of the display buffer.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the editor should be removed from its layout. This cannot be used in query mode.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def undoCache(self, val='True', **kwargs):
        """
        By default the last image is cached for undo. If this is set false, then undoing will be disabled in canvas mode and undo in scene mode will force a full refresh. Less memory will be used if this is set false before the first clear or refresh of the current scene.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def unlockMainConnection(self, val='True', **kwargs):
        """
        Unlocks the mainConnection, effectively restoring the original mainConnection (if it is still available), and dynamic updates.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def updateMainConnection(self, val='True', **kwargs):
        """
        Causes a locked mainConnection to be updated from the orginal mainConnection, but preserves the lock state.                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    def writeImage(self, val='True', **kwargs):
        """
        write the current Editor Image to disk                  
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a editor window that can be painted into
        
        Flags:
        - activeOnly : ao                (bool)          [query,edit]
            For Scene mode, this determines if only the active strokes will be refreshed.
        
        - autoSave : autoSave            (bool)          [query,edit]
            For Canvas mode, this determines if the buffer will be saved to a disk file
            after every stroke. Good for painting textures and viewing the results in shaded
            display in the model view.
        
        - camera : cam                   (unicode)       [query,edit]
            Sets the name of the camera which the Paint Effects panel looks through.
        
        - canvasMode : cm                (bool)          [query,edit]
            Sets the Paint Effects panel into Canvas mode if true.
        
        - canvasUndo : cu                (bool)          [edit]
            Does a fast undo in Canvas mode. This is a special undo because we are not using
            any history when we paint in Canvas mode so we provide a single level undo for
            the Canvas.
        
        - changeCommand : cc             (unicode, unicode, unicode, unicode) [create,query,edit]
            Parameters: First string: commandSecond string: editorNameThird string:
            editorCmdFourth string: updateFuncCall the command when something changes in the
            editor The command should have this prototype :  command(string $editor, string
            $editorCmd, string $updateFunc, int $reason)  The possible reasons could be : 0:
            no particular reason1: scale color2: buffer (single/double)3: axis 4: image
            displayed5: image saved in memory
        
        - clear : cl                     (float, float, float) [edit]
            Clears the buffer (if in Canvas mode) to the floating point values (R,G,B).
        
        - control : ctl                  (bool)          [query]
            Query only. Returns the top level control for this editor. Usually used for
            getting a parent to attach popup menus. Caution: It is possible for an editor to
            exist without a control. The query will return NONEif no control is present.
        
        - currentCanvasSize : ccs        (bool)          [query]
            In Query mode, this returns the (X,Y) resolution of the current canvas.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - displayAppearance : dsa        (unicode)       [query,edit]
            Sets the display appearance of the model panel.  Possible values are wireframe,
            points, boundingBox, smoothShaded, flatShaded.  This flag may be used with the
            -interactive and -default flags.  Note that only wireframe, points, and
            boundingBoxare valid for the interactive mode.
        
        - displayFog : dfg               (bool)          [query,edit]
            For Scene mode, this determines if fog will be displayed in the Paint Effects
            panel when refreshing the scene. If fog is on, but this is off, fog will only be
            drawn on the strokes, not the rest of the scene.
        
        - displayImage : di              (int)           [query,edit]
            Set a particular image in the Editor Image Stack as the current Editor Image.
            Images are added to the Editor Image Stack using the si/saveImageflag.
        
        - displayLights : dsl            (unicode)       [query,edit]
            Sets the lighting for shaded mode.  Possible values are selected, active, all,
            default.
        
        - displayStyle : dst             (unicode)       [create,query,edit]
            Set the mode to display the image. Valid values are: colorto display the basic
            RGB imagemaskto display the mask channellumto display the luminance of the image
        
        - displayTextures : dtx          (bool)          [query,edit]
            Turns on or off display of textures in shaded mode
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the editor.
        
        - doubleBuffer : dbf             (bool)          [create,query,edit]
            Set the display in double buffer mode
        
        - drawAxis : da                  (bool)          [create,query,edit]
            Set or query whether the axis will be drawn.
        
        - drawContext : drc              (bool)          [query]
            Returns the name of the context.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fastUpdate : fu                (int)           []
            Obsolete - do not use
        
        - fileName : fil                 (unicode)       [query,edit]
            This sets the file to which the canvas will be saved.
        
        - filter : f                     (unicode)       [create,query,edit]
            Specifies the name of an itemFilter object to be used with this editor. This
            filters the information coming onto the main list of the editor.
        
        - forceMainConnection : fmc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object. This is a variant of the -mainListConnection flag in
            that it will force a change even when the connection is locked. This flag is
            used to reduce the overhead when using the -unlockMainConnection ,
            -mainListConnection, -lockMainConnection flags in immediate succession.
        
        - highlightConnection : hlc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its highlight list. Not all editors have a highlight list. For
            those that do, it is a secondary selection list.
        
        - iconGrab : ig                  (bool)          [edit]
            This puts the Paint Effects panel into Grab Icon mode where the user is expected
            to drag out a section of the screen to be made into an icon.
        
        - loadImage : li                 (unicode)       [edit]
            load an image from disk and set it as the current Editor Image
        
        - lockMainConnection : lck       (bool)          [create,edit]
            Locks the current list of objects within the mainConnection, so that only those
            objects are displayed within the editor. Further changes to the original
            mainConnection are ignored.
        
        - mainListConnection : mlc       (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will use as
            its source of content. The editor will only display items contained in the
            selectionConnection object.
        
        - menu : mn                      (unicode)       [create]
            Sets the name of the script used to build a menu in the editor. The script takes
            the editor name as an argument.
        
        - nbImages : nim                 (bool)          [query]
            returns the number of images
        
        - newImage : ni                  (int, int, float, float, float) [query,edit]
            Starts a new image in edit mode, setting the resolution to the integer values
            (X,Y) and clearing the buffer to the floating point values (R,G,B). In Query
            mode, this returns the (X,Y) resolution of the current Image.
        
        - paintAll : pa                  (float)         [edit]
            Redraws the buffer in current refresh mode.
        
        - panel : pnl                    (unicode)       [create,query]
            Specifies the panel for this editor. By default if an editor is created in the
            create callback of a scripted panel it will belong to that panel. If an editor
            does not belong to a panel it will be deleted when the window that it is in is
            deleted.
        
        - parent : p                     (unicode)       [create,query,edit]
            Specifies the parent layout for this editor. This flag will only have an effect
            if the editor is currently un-parented.
        
        - redrawLast : rl                (bool)          [edit]
            Redraws the last stroke again. Useful when it's brush has just changed. This
            feature does a fast undo and redraws the stroke again.
        
        - refresh : ref                  (bool)          [edit]
            requests a refresh of the current Editor Image.
        
        - refreshMode : rmd              (int)           [query,edit]
            Sets the refresh mode to the specified value. 0 - Do not draw strokes on
            refresh, 1 - Redraw strokes in wireframe mode, 2 - Redraw strokes in final
            rendered mode.
        
        - removeAllImages : ra           (bool)          [edit]
            remove all the Editor Images from the Editor Image Stack
        
        - removeImage : ri               (bool)          [edit]
            remove the current Editor Image from the Editor Image Stack
        
        - rollImage : rig                (float, float)  [edit]
            In Canvas mode, this rolls the image by the floating point values (X,Y). X and Y
            are between 0 (no roll) and 1 (full roll). A value of .5 rolls the image 50%
            (ie. the border moves to the center of the screen.
        
        - saveAlpha : sa                 (bool)          [query,edit]
            For Canvas mode, this determines if the alpha will be saved when storing the
            canvas to a disk file.
        
        - saveBumpmap : sbm              (unicode)       [query,edit]
            Saves the current buffer as a bump map to the specified file.
        
        - saveImage : si                 (bool)          [edit]
            save the current Editor Image to memory. Saved Editor Images are stored in an
            Editor Image Stack. The most recently saved image is stored in position 0, the
            second most recently saved image in position 1, and so on... To set the current
            Editor Image to a previously saved image use the di/displayImageflag.
        
        - scaleBlue : sb                 (float)         [create,query,edit]
            Define the scaling factor for the blue component in the View. The default value
            is 1 and can be between -1000 to +1000
        
        - scaleGreen : sg                (float)         [create,query,edit]
            Define the scaling factor for the green component in the View. The default value
            is 1 and can be between -1000 to +1000
        
        - scaleRed : sr                  (float)         [create,query,edit]
            Define the scaling factor for the red component in the View. The default value
            is 1 and can be between -1000 to +1000
        
        - selectionConnection : slc      (unicode)       [create,query,edit]
            Specifies the name of a selectionConnection object that the editor will
            synchronize with its own selection list. As the user selects things in this
            editor, they will be selected in the selectionConnection object. If the object
            undergoes changes, the editor updates to show the changes.
        
        - singleBuffer : sbf             (bool)          [create,query,edit]
            Set the display in single buffer mode
        
        - snapShot : snp                 (bool)          [edit]
            Takes a snapshot of the current camera view.
        
        - stateString : sts              (bool)          [query]
            Query only flag. Returns the MEL command that will create an editor to match the
            current editor state. The returned command string uses the string variable
            $editorName in place of a specific name.
        
        - swap : swp                     (int)           []
            Obsolete - do not use
        
        - tileSize : ts                  (int)           [edit]
            Sets the size of the tile for the hardware texture redraw of the display buffer.
        
        - unParent : up                  (bool)          [create,edit]
            Specifies that the editor should be removed from its layout. This cannot be used
            in query mode.
        
        - undoCache : uc                 (bool)          [edit]
            By default the last image is cached for undo. If this is set false, then undoing
            will be disabled in canvas mode and undo in scene mode will force a full
            refresh. Less memory will be used if this is set false before the first clear or
            refresh of the current scene.
        
        - unlockMainConnection : ulk     (bool)          [create,edit]
            Unlocks the mainConnection, effectively restoring the original mainConnection
            (if it is still available), and dynamic updates.
        
        - updateMainConnection : upd     (bool)          [create,edit]
            Causes a locked mainConnection to be updated from the orginal mainConnection,
            but preserves the lock state.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - wrap : wr                      (bool, bool)    [query,edit]
            For Canvas mode, should the buffer wrap in U, and V (respectively) when
            painting.
        
        - writeImage : wi                (unicode)       [edit]
            write the current Editor Image to disk
        
        - zoom : zm                      (float)         [query,edit]
            Zooms the Canvas image by the specified value.                  Flag can have
            multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.dynPaintEditor`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'dynPaintEditor'
    
    
    __melui__ = 'dynPaintEditor'


class AttributeMenu(PyUI):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Action to generate popup connection menus for Hypershade. This command is used
        internally by the Hypershade panel.
        
        Flags:
        - beginMenu : beg                (bool)          [create]
            If true the menu will be used to start a connection edit so it will list all
            available attributes for either inputs or outputs.  If false the menu will be
            used to complete a connection so it will list only the attributes compatible
            with the attribute at the other end of the connection.  A plug must be supplied
            in this case.
        
        - editor : edt                   (unicode)       [create]
            Name of the Hypergraph, Hypershade or Visor editor for which this menu is being
            built.  This argument is no longer mandatory. If it is omitted, the inputs flag
            and the node must be used to specify the search targets. This allows
            attributeMenu to be used in the absence of a hypershade editor.
        
        - finishMenu : fsh               (bool)          [create]
            finishes the menu
        
        - inputs : inp                   (bool)          [create]
            If true only attributes which can be used as inputs will be listed.  If false
            only attributes which can be used as outputs will be listed
        
        - plug : p                       (PyNode)        [create]
            If inputs is false then we are completing a connection and the name of the plug
            at the other end of the connection must be supplied.
        
        - regPulldownMenuCommand : rpm   (unicode)       [create]
            This flag will register a callback that allows the user to define their own
            popup menu for a specific node type for use in the Hypershade and Hypergraph
            editor. The command signature should look like this: global proc int
            proc_name(string $editorName, string $nodeName, string $plug, string $mode,
            string $menuType) The method should return 0 if it does not recognize the node
            type and the default attributeMenu popup menu will be displayed. If the callback
            returns one then the menu is considered built and no other menuItems will be
            added to the popup. The return value from this flag will be the ID to use for
            the -unregPulldownMenuCommand flag.
        
        - unregPulldownMenuCommand : upm (int)           [create]
            This flag will unregister a callback procedure that was registered with the
            -regPulldownMenuCommand flag. The argument should be the integer identifier
            returned from the -regPulldownMenuCommand flag.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attributeMenu`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attributeMenu'
    
    
    __melui__ = 'attributeMenu'


class SymbolCheckBox(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the check box's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the check box from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getDisableOffImage(self, **kwargs):
        """
        Image displayed when the check box is off and disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getDisableOnImage(self, **kwargs):
        """
        Image displayed when the check box is on and disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getImage(self, **kwargs):
        """
        Image of the check box.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getInnerMargin(self, **kwargs):
        """
        This flag will revert the symbolCheckBox to its pre Maya 2.5 behaviour of having a 2 pixel inner margin. This flag is for backward compatibility on Linux only, and will be removed in future releases.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2017, 2018). Currently only accepts major version numbers (e.g. 2017 Ext 1, or 2017.5 should be given as 2018).                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getOffImage(self, **kwargs):
        """
        Image displayed when the check box is off.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getOnImage(self, **kwargs):
        """
        Image displayed when the check box is on.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the check box.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2017, 2018). Currently only accepts major version numbers (e.g. 2017 Ext 1, or 2017.5 should be given as 2018).                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def offCommand(self, val='True', **kwargs):
        """
        Command executed when the symbol check box is turned off.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def onCommand(self, val='True', **kwargs):
        """
        Command executed when the symbol check box is turned on.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setDisableOffImage(self, val='True', **kwargs):
        """
        Image displayed when the check box is off and disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setDisableOnImage(self, val='True', **kwargs):
        """
        Image displayed when the check box is on and disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Image of the check box.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setInnerMargin(self, val='True', **kwargs):
        """
        This flag will revert the symbolCheckBox to its pre Maya 2.5 behaviour of having a 2 pixel inner margin. This flag is for backward compatibility on Linux only, and will be removed in future releases.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2017, 2018). Currently only accepts major version numbers (e.g. 2017 Ext 1, or 2017.5 should be given as 2018).                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setOffImage(self, val='True', **kwargs):
        """
        Image displayed when the check box is off.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setOnImage(self, val='True', **kwargs):
        """
        Image displayed when the check box is on.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the check box.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2017, 2018). Currently only accepts major version numbers (e.g. 2017 Ext 1, or 2017.5 should be given as 2018).                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a symbol check box.  A symbol check box is a simple control
        containing a pixmap and a state of either on or off. Commands can be attached to
        any or all of the following events:  when the symbol check box is turned on,
        turned off, or simply when it's state is changed.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the check box's state is changed. Note that this flag
            should not be used in conjunction with onCommand and offCommand. That is, one
            should either use changeCommand and test the state of the check box from inside
            the callback, or use onCommand and offCommand as separate callbacks.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disableOffImage : dfi          (unicode)       [create,query,edit]
            Image displayed when the check box is off and disabled.
        
        - disableOnImage : dni           (unicode)       [create,query,edit]
            Image displayed when the check box is on and disabled.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - image : i                      (unicode)       [create,query,edit]
            Image of the check box.
        
        - innerMargin : im               (bool)          [create,query,edit]
            This flag will revert the symbolCheckBox to its pre Maya 2.5 behaviour of having
            a 2 pixel inner margin. This flag is for backward compatibility on Linux only,
            and will be removed in future releases.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2017, 2018). Currently only accepts major version numbers (e.g.
            2017 Ext 1, or 2017.5 should be given as 2018).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - offCommand : ofc               (script)        [create,edit]
            Command executed when the symbol check box is turned off.
        
        - offImage : ofi                 (unicode)       [create,query,edit]
            Image displayed when the check box is off.
        
        - onCommand : onc                (script)        [create,edit]
            Command executed when the symbol check box is turned on.
        
        - onImage : oni                  (unicode)       [create,query,edit]
            Image displayed when the check box is on.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (bool)          [create,query,edit]
            Value of the check box.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this control feature was introduced. The argument
            should be given as a string of the version number (e.g. 2017, 2018). Currently
            only accepts major version numbers (e.g. 2017 Ext 1, or 2017.5 should be given
            as 2018).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.symbolCheckBox`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'symbolCheckBox'
    
    
    __melui__ = 'symbolCheckBox'


class IconTextStaticLabel(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getAlign(self, **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getDisabledImage(self, **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getFlipX(self, **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getFlipY(self, **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getImage(self, **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getImage1(self, **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getImage2(self, **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getImage3(self, **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getLabelOffset(self, **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getMarginHeight(self, **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getMarginWidth(self, **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getOverlayLabelBackColor(self, **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getOverlayLabelColor(self, **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getRotation(self, **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getStyle(self, **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getUseAlpha(self, **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setDisabledImage(self, val='True', **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setFlipX(self, val='True', **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setFlipY(self, val='True', **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setImage1(self, val='True', **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setImage2(self, val='True', **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setImage3(self, val='True', **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setLabelOffset(self, val='True', **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setMarginHeight(self, val='True', **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setMarginWidth(self, val='True', **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setOverlayLabelBackColor(self, val='True', **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setOverlayLabelColor(self, val='True', **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setRotation(self, val='True', **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setUseAlpha(self, val='True', **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This control supports up to 3 icon images and 4 different display styles.  The
        icon image displayed is the one that best fits the current size of the control
        given its current style. This command creates an iconTextStaticLabel.
        
        Flags:
        - align : al                     (unicode)       [create,query,edit]
            The label alignment.  Alignment values are left, right, and center. By default,
            the label is aligned center. Currently only available when -st/style is set to
            iconAndTextCentered.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disabledImage : di             (unicode)       [create,query,edit]
            Image used when the button is disabled. Image size must be the same as the image
            specified with the i/imageflag. This is a Windows only flag.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - flipX : fx                     (bool)          [create,query,edit]
            Is the image flipped horizontally?
        
        - flipY : fy                     (bool)          [create,query,edit]
            Is the image flipped vertically?
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - image : i                      (unicode)       [create,query,edit]
            If you are not providing images with different sizes then you may use this flag
            for the control's image. If the iconOnlystyle is set, the icon will be scaled to
            the size of the control.
        
        - image1 : i1                    (unicode)       [create,query,edit]
            First of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image2 : i2                    (unicode)       [create,query,edit]
            Second of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image3 : i3                    (unicode)       [create,query,edit]
            Third of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            A short string, up to 6 characters, representing a label that will be displayed
            on top of the image.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The text that appears in the control.
        
        - labelOffset : lo               (int)           [create,query,edit]
            The label offset. Default is 0. Currently only available when -st/style is set
            to iconAndTextCentered.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - marginHeight : mh              (int)           [create,query,edit]
            The number of pixels above and below the control content. The default value is 1
            pixel.
        
        - marginWidth : mw               (int)           [create,query,edit]
            The number of pixels on either side of the control content. The default value is
            1 pixel.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - overlayLabelBackColor : olb    (float, float, float, float) [create,query,edit]
            The RGBA color of the shadow behind the label defined by imageOverlayLabel.
            Default is 50% transparent black: 0 0 0 .5
        
        - overlayLabelColor : olc        (float, float, float) [create,query,edit]
            The RGB color of the label defined by imageOverlayLabel. Default is a light
            grey: .8 .8 .8
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rotation : rot                 (float)         [create,query,edit]
            The rotation value of the image in radians.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            The draw style of the control.  Valid styles are iconOnly, textOnly,
            iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note:
            iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set,
            the icon will be scaled to the size of the control.
        
        - useAlpha : ua                  (bool)          [create,query,edit]
            Is the image using alpha channel?
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this control feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.iconTextStaticLabel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'iconTextStaticLabel'
    
    
    __melui__ = 'iconTextStaticLabel'


class AnimDisplay(PyUI):
    def getModelUpdate(self, **kwargs):
        """
        Controls how changes to animCurves are propagated through the dependency graph. Valid modes are none, interactiveor delayed. If modelUpdate is nonethen changing an animCurve will not cause the model to be updated (change currentTime in order to update the model).  If modelUpdate is interactive(which is the default setting), then as interactive changes are being made to the animCurve, the model will be updated.  If modelUpdate is delayed, then the model is updated once the final change to an animCurve has been made.  With modelUpdate set to either interactiveor delayed, changes to animCurves made via commands will also cause the model to be updated.                  
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    def getRefAnimCurvesEditable(self, **kwargs):
        """
        Specify if animation curves from referenced files are editable.                  
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    def getTimeCode(self, **kwargs):
        """
        Controls how time value are display. Valid values are frame, timecode, fulltimecode. If the value is framemaya will display time in frame everywhere. If the value is timecodemaya will display time in timecode in time slider, graph editor and dope sheet. If the value is fulltimecodemaya will display time in timecode everywhere.                  
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    def getTimeCodeOffset(self, **kwargs):
        """
        This flag has now been deprecated.  It still exists to not break legacy scripts, but it will now do nothing.  See the new timeCode command to set and query timeCodes.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    def setModelUpdate(self, val='True', **kwargs):
        """
        Controls how changes to animCurves are propagated through the dependency graph. Valid modes are none, interactiveor delayed. If modelUpdate is nonethen changing an animCurve will not cause the model to be updated (change currentTime in order to update the model).  If modelUpdate is interactive(which is the default setting), then as interactive changes are being made to the animCurve, the model will be updated.  If modelUpdate is delayed, then the model is updated once the final change to an animCurve has been made.  With modelUpdate set to either interactiveor delayed, changes to animCurves made via commands will also cause the model to be updated.                  
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    def setRefAnimCurvesEditable(self, val='True', **kwargs):
        """
        Specify if animation curves from referenced files are editable.                  
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    def setTimeCode(self, val='True', **kwargs):
        """
        Controls how time value are display. Valid values are frame, timecode, fulltimecode. If the value is framemaya will display time in frame everywhere. If the value is timecodemaya will display time in timecode in time slider, graph editor and dope sheet. If the value is fulltimecodemaya will display time in timecode everywhere.                  
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    def setTimeCodeOffset(self, val='True', **kwargs):
        """
        This flag has now been deprecated.  It still exists to not break legacy scripts, but it will now do nothing.  See the new timeCode command to set and query timeCodes.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command changes certain display options used by animation windows. In query
        mode, return type is based on queried flag.
        
        Flags:
        - modelUpdate : upd              (unicode)       [create,query,edit]
            Controls how changes to animCurves are propagated through the dependency graph.
            Valid modes are none, interactiveor delayed. If modelUpdate is nonethen changing
            an animCurve will not cause the model to be updated (change currentTime in order
            to update the model).  If modelUpdate is interactive(which is the default
            setting), then as interactive changes are being made to the animCurve, the model
            will be updated.  If modelUpdate is delayed, then the model is updated once the
            final change to an animCurve has been made.  With modelUpdate set to either
            interactiveor delayed, changes to animCurves made via commands will also cause
            the model to be updated.
        
        - refAnimCurvesEditable : rae    (bool)          [create,query,edit]
            Specify if animation curves from referenced files are editable.
        
        - timeCode : tc                  (unicode)       [create,query,edit]
            Controls how time value are display. Valid values are frame, timecode,
            fulltimecode. If the value is framemaya will display time in frame everywhere.
            If the value is timecodemaya will display time in timecode in time slider, graph
            editor and dope sheet. If the value is fulltimecodemaya will display time in
            timecode everywhere.
        
        - timeCodeOffset : tco           (unicode)       [create,query,edit]
            This flag has now been deprecated.  It still exists to not break legacy scripts,
            but it will now do nothing.  See the new timeCode command to set and query
            timeCodes.                  Flag can have multiple arguments, passed either as a
            tuple or a list.
        
        
        Derived from mel command `maya.cmds.animDisplay`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'animDisplay'
    
    
    __melui__ = 'animDisplay'


class PalettePort(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        This command string will be executed when a color in the palette is changed.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def colorEdited(self, val='True', **kwargs):
        """
        This command string will be executed when a color in the palette is edited.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getActualTotal(self, **kwargs):
        """
        Set the actual number of palette entries. This number must be greater than zero, but not be greater than maximum number of palette entries defined by the dimensionsflag.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getColorEditable(self, **kwargs):
        """
        If true then the user can modify the current index's color.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getDimensions(self, **kwargs):
        """
        Set the dimensions of the array.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getEditable(self, **kwargs):
        """
        If true then the user can change the current color.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getHsvValue(self, **kwargs):
        """
        Set a color for a given cell, using HSV format. On query return the color of the current cell.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getRgbValue(self, **kwargs):
        """
        Set a color for a given cell, using RGB format. On query return the color of the current cell.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getSetCurCell(self, **kwargs):
        """
        Set the current cell in the array to the given index. Returns the current cell when queried.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getTransparent(self, **kwargs):
        """
        Set a given cell to be the transparent color.  A cell value of -1 indicates that no cell is transparent.  On query returns the current transparent cell.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def redraw(self, val='True', **kwargs):
        """
        Forces a redraw of the array                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setColorEditable(self, val='True', **kwargs):
        """
        If true then the user can modify the current index's color.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        If true then the user can change the current color.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setHsvValue(self, val='True', **kwargs):
        """
        Set a color for a given cell, using HSV format. On query return the color of the current cell.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setRgbValue(self, val='True', **kwargs):
        """
        Set a color for a given cell, using RGB format. On query return the color of the current cell.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setSetCurCell(self, val='True', **kwargs):
        """
        Set the current cell in the array to the given index. Returns the current cell when queried.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setTransparent(self, val='True', **kwargs):
        """
        Set a given cell to be the transparent color.  A cell value of -1 indicates that no cell is transparent.  On query returns the current transparent cell.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates an array of color cells. It could be used to to store an
        retrieve some colors you want to manage during your working session.
        
        Flags:
        - actualTotal : at               (int)           [create,query]
            Set the actual number of palette entries. This number must be greater than zero,
            but not be greater than maximum number of palette entries defined by the
            dimensionsflag.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            This command string will be executed when a color in the palette is changed.
        
        - colorEditable : ced            (bool)          [create,query,edit]
            If true then the user can modify the current index's color.
        
        - colorEdited : ce               (script)        [create,edit]
            This command string will be executed when a color in the palette is edited.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - dimensions : dim               (int, int)      [create,query]
            Set the dimensions of the array.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            If true then the user can change the current color.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - hsvValue : hsv                 (int, int, float, float, float) [create,query,edit]
            Set a color for a given cell, using HSV format. On query return the color of the
            current cell.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - redraw : r                     (bool)          [create,edit]
            Forces a redraw of the array
        
        - rgbValue : rgb                 (int, float, float, float) [create,query,edit]
            Set a color for a given cell, using RGB format. On query return the color of the
            current cell.
        
        - setCurCell : scc               (int)           [create,query,edit]
            Set the current cell in the array to the given index. Returns the current cell
            when queried.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - topDown : td                   (bool)          [create]
            If this flag is true, it indicates that first entry should appear in top left as
            opposed to the bottom left.
        
        - transparent : t                (int)           [create,query,edit]
            Set a given cell to be the transparent color.  A cell value of -1 indicates that
            no cell is transparent.  On query returns the current transparent cell.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.palettePort`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'palettePort'
    
    
    __melui__ = 'palettePort'


class RadioMenuItemCollection(PyUI):
    def getGl(self, **kwargs):
        """
        Set the collection to have no parent menu.  Global collections must be explicitly deleted.                  
        
        
        Derived from mel command `maya.cmds.radioMenuItemCollection`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a radioMenuItemCollection.  Attach radio menu items to
        radio menu item collection objects to get radio button behaviour.  Radio menu
        item collections will be parented to the current menu if no parent is specified
        with the -p/parentflag. As children of the menu they will be deleted when the
        menu is deleted. Collections may also span more than one menu if the
        -g/globalflag is used. In this case the collection has no parent menu and must
        be explicitly deleted with the deleteUIcommand when it is no longer wanted.
        
        Flags:
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - gl : gl                        (bool)          [create,query]
            Set the collection to have no parent menu.  Global collections must be
            explicitly deleted.
        
        - parent : p                     (unicode)       [create]
            The parent of the collection.  The collection will be deleted along with the
            parent.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.radioMenuItemCollection`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'radioMenuItemCollection'
    
    
    __melui__ = 'radioMenuItemCollection'


class IconTextButton(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getAlign(self, **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getCommand(self, **kwargs):
        """
        Command executed when the control is pressed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getCommandRepeatable(self, **kwargs):
        """
        Set if the MEL command specified in the command flag should be repeatable or not.  The gkey, by default, is the shortcut to repeat the last executed command.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getDisabledImage(self, **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getDoubleClickCommand(self, **kwargs):
        """
        Command executed when the control is double clicked.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getFlat(self, **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getFlipX(self, **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getFlipY(self, **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getHighlightImage(self, **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getImage(self, **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getImage1(self, **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getImage2(self, **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getImage3(self, **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getLabelOffset(self, **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getMarginHeight(self, **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getMarginWidth(self, **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getOverlayLabelBackColor(self, **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getOverlayLabelColor(self, **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getRotation(self, **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getSelectionImage(self, **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getSourceType(self, **kwargs):
        """
        Sets the language type for the command script. Can only be used in conjunction with the c/command or dcc/doubleClickCommand flags. Valid values are mel(enabled by default), and python.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getStyle(self, **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getUseAlpha(self, **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def handleNodeDropCallback(self, val='True', **kwargs):
        """
        Specify a script callback which is called when a node is dropped on the control.  The name of the node being dropped will be passed to the function  (python callable) or appended to the end (script) to form the command to be executed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def labelEditingCallback(self, val='True', **kwargs):
        """
        Specify a callback which is called after the user double clicks the label of the control to give it a new label. The new label string will be passed to the callback.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def scaleIcon(self, val='True', **kwargs):
        """
        For textOnlyand iconOnlystyle, this flag has no effect. For other styles, if the flag is specified, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setCommand(self, val='True', **kwargs):
        """
        Command executed when the control is pressed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setCommandRepeatable(self, val='True', **kwargs):
        """
        Set if the MEL command specified in the command flag should be repeatable or not.  The gkey, by default, is the shortcut to repeat the last executed command.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setDisabledImage(self, val='True', **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setDoubleClickCommand(self, val='True', **kwargs):
        """
        Command executed when the control is double clicked.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setFlat(self, val='True', **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setFlipX(self, val='True', **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setFlipY(self, val='True', **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setHighlightImage(self, val='True', **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setImage1(self, val='True', **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setImage2(self, val='True', **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setImage3(self, val='True', **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setLabelOffset(self, val='True', **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setMarginHeight(self, val='True', **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setMarginWidth(self, val='True', **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setOverlayLabelBackColor(self, val='True', **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setOverlayLabelColor(self, val='True', **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setRotation(self, val='True', **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setSelectionImage(self, val='True', **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setSourceType(self, val='True', **kwargs):
        """
        Sets the language type for the command script. Can only be used in conjunction with the c/command or dcc/doubleClickCommand flags. Valid values are mel(enabled by default), and python.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setUseAlpha(self, val='True', **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This control supports up to 3 icon images and 4 different display styles.  The
        icon image displayed is the one that best fits the current size of the control
        given its current style. This command creates an iconTextButton that can be
        displayed with different icons, with or without accompanying text label. When an
        argument is passed, it is used to give a name to the iconTextButton.
        
        Flags:
        - actionIsSubstitute : ais       (bool)          []
        
        - align : al                     (unicode)       [create,query,edit]
            The label alignment.  Alignment values are left, right, and center. By default,
            the label is aligned center. Currently only available when -st/style is set to
            iconAndTextCentered.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - command : c                    (script)        [create,query,edit]
            Command executed when the control is pressed.
        
        - commandRepeatable : rpt        (bool)          [create,query,edit]
            Set if the MEL command specified in the command flag should be repeatable or
            not.  The gkey, by default, is the shortcut to repeat the last executed command.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disabledImage : di             (unicode)       [create,query,edit]
            Image used when the button is disabled. Image size must be the same as the image
            specified with the i/imageflag. This is a Windows only flag.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,query,edit]
            Command executed when the control is double clicked.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - flat : fla                     (bool)          [create,query,edit]
            Sets whether the control will be a flat button (0 false, 1 true).
        
        - flipX : fx                     (bool)          [create,query,edit]
            Is the image flipped horizontally?
        
        - flipY : fy                     (bool)          [create,query,edit]
            Is the image flipped vertically?
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - handleNodeDropCallback : hnd   (script)        [create,edit]
            Specify a script callback which is called when a node is dropped on the control.
            The name of the node being dropped will be passed to the function  (python
            callable) or appended to the end (script) to form the command to be executed.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - highlightImage : hi            (unicode)       [create,query,edit]
            Highlight image displayed while the cursor is over the control. Image size must
            be the same as the image specified with the -i/imageflag. This is a Windows only
            flag.
        
        - image : i                      (unicode)       [create,query,edit]
            If you are not providing images with different sizes then you may use this flag
            for the control's image. If the iconOnlystyle is set, the icon will be scaled to
            the size of the control.
        
        - image1 : i1                    (unicode)       [create,query,edit]
            First of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image2 : i2                    (unicode)       [create,query,edit]
            Second of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image3 : i3                    (unicode)       [create,query,edit]
            Third of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            A short string, up to 6 characters, representing a label that will be displayed
            on top of the image.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The text that appears in the control.
        
        - labelEditingCallback : lec     (script)        [create,edit]
            Specify a callback which is called after the user double clicks the label of the
            control to give it a new label. The new label string will be passed to the
            callback.
        
        - labelOffset : lo               (int)           [create,query,edit]
            The label offset. Default is 0. Currently only available when -st/style is set
            to iconAndTextCentered.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - marginHeight : mh              (int)           [create,query,edit]
            The number of pixels above and below the control content. The default value is 1
            pixel.
        
        - marginWidth : mw               (int)           [create,query,edit]
            The number of pixels on either side of the control content. The default value is
            1 pixel.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - overlayLabelBackColor : olb    (float, float, float, float) [create,query,edit]
            The RGBA color of the shadow behind the label defined by imageOverlayLabel.
            Default is 50% transparent black: 0 0 0 .5
        
        - overlayLabelColor : olc        (float, float, float) [create,query,edit]
            The RGB color of the label defined by imageOverlayLabel. Default is a light
            grey: .8 .8 .8
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rotation : rot                 (float)         [create,query,edit]
            The rotation value of the image in radians.
        
        - scaleIcon : sic                (bool)          [create,edit]
            For textOnlyand iconOnlystyle, this flag has no effect. For other styles, if the
            flag is specified, the icon will be scaled to the size of the control.
        
        - selectionImage : si            (unicode)       [create,query,edit]
            Image displayed while the control is selected. Image size must be the same as
            the image specified with the -i/imageflag. This is a Windows only flag.
        
        - sourceType : stp               (unicode)       [create,query,edit]
            Sets the language type for the command script. Can only be used in conjunction
            with the c/command or dcc/doubleClickCommand flags. Valid values are mel(enabled
            by default), and python.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            The draw style of the control.  Valid styles are iconOnly, textOnly,
            iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note:
            iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set,
            the icon will be scaled to the size of the control.
        
        - useAlpha : ua                  (bool)          [create,query,edit]
            Is the image using alpha channel?
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this control feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.iconTextButton`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'iconTextButton'
    
    
    __melui__ = 'iconTextButton'


class ToolCollection(PyUI):
    def getCollectionItemArray(self, **kwargs):
        """
        Returns a string list giving the long names of all the items in this collection.                  
        
        
        Derived from mel command `maya.cmds.toolCollection`
        """
        pass
    def getGl(self, **kwargs):
        """
        Set the collection to have no parent layout.  This flag must be specified when the collection is created and can not be queried or edited.  Consequently, global collections must be explicitly deleted.                  
        
        
        Derived from mel command `maya.cmds.toolCollection`
        """
        pass
    def getNumberOfCollectionItems(self, **kwargs):
        """
        Returns the number of items that are in this collection.                  
        
        
        Derived from mel command `maya.cmds.toolCollection`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Select the specified collection item.  If queried will return the name of the currently selected collection item.                  
        
        
        Derived from mel command `maya.cmds.toolCollection`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Select the specified collection item.  If queried will return the name of the currently selected collection item.                  
        
        
        Derived from mel command `maya.cmds.toolCollection`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a tool button collection. Collections are parented to the
        current default layout if no parent is specified with the -p/parent flag.  As
        children of the layout they will be deleted when the layout is deleted.
        Collections may also span more than one window if the -gl/global flag is used.
        In this case the collection has no parent and must be explicitly deleted with
        the 'deleteUI' command when it is no longer wanted.
        
        Flags:
        - collectionItemArray : cia      (bool)          [query]
            Returns a string list giving the long names of all the items in this collection.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - gl : gl                        (bool)          [create,query]
            Set the collection to have no parent layout.  This flag must be specified when
            the collection is created and can not be queried or edited.  Consequently,
            global collections must be explicitly deleted.
        
        - numberOfCollectionItems : nci  (bool)          [query]
            Returns the number of items that are in this collection.
        
        - parent : p                     (unicode)       [create]
            Specify the parent to associate the collection with.  The collection will be
            deleted along with the parent.  This flag must be specified when the collection
            is created and can not be edited.
        
        - select : sl                    (unicode)       [create,query,edit]
            Select the specified collection item.  If queried will return the name of the
            currently selected collection item.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.toolCollection`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'toolCollection'
    
    
    __melui__ = 'toolCollection'


class ScriptTable(PyUI):
    def afterCellChangedCmd(self, val='True', **kwargs):
        """
        Sets the script to call after the value of a cell has been changed. The procedure is called with 2 integer arguments specifying the row and column for which the value was changed. The 3rd argument is the string which was entered into that cell. The procedure does not need to return any value. The row and column numbers passed in are 1-based (i.e. (1,1) is the upper left cell). The procedure should be of the form: global proc procedureName(int $row, int $column, string $value) 
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def cellBackgroundColorCommand(self, val='True', **kwargs):
        """
        Sets the script to call when it requires the background color of a cell. The procedure is called with 2 integer arguments specifying the row and column for which the value is required. The procedure should return an array of ints which is the RGB color value for the cell. The row and column numbers passed in are 1-based (i.e. (1,1) is the upper left cell). The procedure should be of the form: global proc int[] procedureName(int $row, int $column) { return {255,0,0}; // return Red as cell background color } 
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def cellChangedCmd(self, val='True', **kwargs):
        """
        Sets the script to call when somebody has changed the value of a cell. The procedure is called with 2 integer arguments specifying the row and column for which the value was changed. The 3rd argument is the string which was entered into that cell. The procedure should return an integer value which indicates whether that value should be accepted (return 1 if yes, and 0 if no). The row and column numbers passed in are 1-based (i.e. (1,1) is the upper left cell). The procedure should be of the form: global proc int procedureName(int $row, int $column, string $value) 
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def cellForegroundColorCommand(self, val='True', **kwargs):
        """
        Sets the script to call when it requires the foreground color of a cell. The procedure is called with 2 integer arguments specifying the row and column for which the value is required. The procedure should return an array of ints which is the RGB color value for the cell. The row and column numbers passed in are 1-based (i.e. (1,1) is the upper left cell). The procedure should be of the form: global proc int[] procedureName(int $row, int $column) { return {0,0,0}; // return Black as Text color } 
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def clearRow(self, val='True', **kwargs):
        """
        Clear the contents for all the cells on the specified row. Any procedure specified by the -gcc flag will be called to populate the cleared cells The row number is 1-based (i.e. the first row is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def clearTable(self, val='True', **kwargs):
        """
        Clears the contents of all the cells in the table. Any procedure specified by the -gcc flag will be called to populate the cleared cells                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def columnFilter(self, val='True', **kwargs):
        """
        Filter the specified column with the string value provided. Set filter to columns 0 will apply the filter to all columns. The filter is case insensitive and support wildcards. Wildcard Matching: Wildcard matching is much simpler than full regexps and has only four features: c    Any character represents itself apart from those mentioned below. Thus c matches the character c. ?     Matches any single character. It is the same as . in full regexps. \*   Matches zero or more of any characters. It is the same as .\* in full regexps. [...]    Sets of characters can be represented in square brackets, similar to full regexps. Within the character class, backslash has no special meaning. (i.e. you can search for MyValuewith y\*uor ??Val??or [MyThe]Valueor any letters in MyValueThe column number is 1-based (i.e. the first row is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Set the width of the specified column The column number is 1-based (ie. the first column is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def deleteRow(self, val='True', **kwargs):
        """
        Delete the specified row The row number is 1-based (i.e. the first row is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getCellCmd(self, val='True', **kwargs):
        """
        Sets the script to call when it requires the contents of a cell. The procedure is called with 2 integer arguments specifying the row and column for which the value is required. The procedure should return a string which is the value for the cell. The row and column numbers passed in are 1-based (ie. (1,1) is the upper left cell). The procedure should be of the form: global proc string procedureName(int $row, int $column) 
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getCellIndex(self, **kwargs):
        """
        used with cellValue , to give the index of row and column This flag and its argument must be passed to the command before the -q flag (see examples).       
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getCellValue(self, **kwargs):
        """
        query and set the cell value on the table by the index of row and column referred in flag -cellIndex.In edit mode, if flag -multiEditEnabled is True and any cell is selected, the flag -cellIndex is not used and the selected cells will be changed.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getColumns(self, **kwargs):
        """
        Set the number of columns in the table                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the table. By default, this flag is set to true, and the table can be edited. If false, then the table is 'read only' and cannot be typed into.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getExcludingHeaders(self, **kwargs):
        """
        when querying the count for the rows or the columns , the number returned will not include the headers                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getMultiEditEnabled(self, **kwargs):
        """
        True: scriptTable support multi-editing function                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getRowHeight(self, **kwargs):
        """
        Sets the height for each row in the scriptTable                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getRows(self, **kwargs):
        """
        Set the number of rows in the table                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getSelectedCells(self, **kwargs):
        """
        Select the cells or return  the cells currently selected. This returns a list of indices, the first of each pair is the row, the second is the column, repeated for each cell selected The returned cell numbers are 1-based (ie. the first row is 1 not 0, the first column is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getSelectedColumns(self, **kwargs):
        """
        select the columns or return the columns currently selected. This returns a list of indices of each column completely selected The returned column numbers are 1-based                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getSelectedRow(self, **kwargs):
        """
        The current row selected. The returned row number is 1-based (ie. the first row is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getSelectedRows(self, **kwargs):
        """
        In edit mode, select the rows given as argument. In query mode, return a list of indices of completely selected rows. The row numbers are 1-based                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getSelectionBehavior(self, **kwargs):
        """
        Set the selection behavior, valid values are from 0 to 2 (inclusive) 0 - Selecting single items. 1 - Selecting only rows. 2 - Selecting only columns.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getSelectionMode(self, **kwargs):
        """
        Set the selection Mode, valid values are from 0 to 4 (inclusive)0 - Items cannot be selected.1 - When the user selects an item, any already-selected item becomes unselected, and the user cannot unselect the selected item by clicking on it.2 - When the user selects an item in the usual way, the selection status of that item is toggled and the other items are left alone. Multiple items can be toggled by dragging the mouse over them.3 - When the user selects an item in the usual way, the selection is cleared and the new item selected. However, if the user presses the Ctrl key when clicking on an item, the clicked item gets toggled and all other items are left untouched. If the user presses the Shift key while clicking on an item, all items between the current item and the clicked item are selected or unselected, depending on the state of the clicked item. Multiple items can be selected by dragging the mouse over them.4 - When the user selects an item in the usual way, the selection is cleared and the new item selected. However, if the user presses the Shift key while clicking on an item, all items between the current item and the clicked item are selected or unselected, depending on the state of the clicked item.
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getSortEnabled(self, **kwargs):
        """
        enable scriptTable sorted by column default value is false and the whole row will be sorted                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getUnderPointerColumn(self, **kwargs):
        """
        The column under the pointer. The returned column number is 1-based (i.e. the first column is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getUnderPointerRow(self, **kwargs):
        """
        The row under the pointer. The returned row number is 1-based (i.e. the first row is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getUseDoubleClickEdit(self, **kwargs):
        """
        this controls the cell edit modeFalse: Click in the cell to select (in Row selection, the last cell of the row is edited, in Column selection, the last cell of the column is edited)(default) True:  Clicked in cell is edited when double-clicked only                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def insertRow(self, val='True', **kwargs):
        """
        Insert an empty row before the specified row. Any procedure specified by the -gcc flag will be called to populate the new new cells. The row number is 1-based (i.e. the first row is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def label(self, val='True', **kwargs):
        """
        Set the label of the specified column. The column number is 1-based (ie. the first column is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def rowsRemovedCmd(self, val='True', **kwargs):
        """
        Sets the script to call after rows are removed by pressing 'delete' or 'backspace' key. The procedure is called with one argument specifying that selected rows have been removed. The rows passed in are 1-based. The procedure should be of the form: global proc procedureName(int $rows[]) 
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def rowsToBeRemovedCmd(self, val='True', **kwargs):
        """
        Sets the script to call when 'delete' or 'backspace' key is pressed. The procedure is called with one argument specifying the selected rows to be removed. The procedure should return an integer value which indicates whether the selected rows should be removed (return 1 if yes, and 0 if no). The rows passed in are 1-based. The procedure should be of the form: global proc int procedureName(int $rows[]) 
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def selectionChangedCmd(self, val='True', **kwargs):
        """
        Sets the script to call when a complete selection operation triggered by the user has occurred successfully. The script does not pass any parameters and does not need to return any value (i.e. It is simply a notification mechanism).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setCellIndex(self, val='True', **kwargs):
        """
        used with cellValue , to give the index of row and column This flag and its argument must be passed to the command before the -q flag (see examples).       
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setCellValue(self, val='True', **kwargs):
        """
        query and set the cell value on the table by the index of row and column referred in flag -cellIndex.In edit mode, if flag -multiEditEnabled is True and any cell is selected, the flag -cellIndex is not used and the selected cells will be changed.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setColumns(self, val='True', **kwargs):
        """
        Set the number of columns in the table                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the table. By default, this flag is set to true, and the table can be edited. If false, then the table is 'read only' and cannot be typed into.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setMultiEditEnabled(self, val='True', **kwargs):
        """
        True: scriptTable support multi-editing function                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setRowHeight(self, val='True', **kwargs):
        """
        Sets the height for each row in the scriptTable                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setRows(self, val='True', **kwargs):
        """
        Set the number of rows in the table                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setSelectedCells(self, val='True', **kwargs):
        """
        Select the cells or return  the cells currently selected. This returns a list of indices, the first of each pair is the row, the second is the column, repeated for each cell selected The returned cell numbers are 1-based (ie. the first row is 1 not 0, the first column is 1 not 0).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setSelectedColumns(self, val='True', **kwargs):
        """
        select the columns or return the columns currently selected. This returns a list of indices of each column completely selected The returned column numbers are 1-based                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setSelectedRows(self, val='True', **kwargs):
        """
        In edit mode, select the rows given as argument. In query mode, return a list of indices of completely selected rows. The row numbers are 1-based                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setSelectionBehavior(self, val='True', **kwargs):
        """
        Set the selection behavior, valid values are from 0 to 2 (inclusive) 0 - Selecting single items. 1 - Selecting only rows. 2 - Selecting only columns.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setSelectionMode(self, val='True', **kwargs):
        """
        Set the selection Mode, valid values are from 0 to 4 (inclusive)0 - Items cannot be selected.1 - When the user selects an item, any already-selected item becomes unselected, and the user cannot unselect the selected item by clicking on it.2 - When the user selects an item in the usual way, the selection status of that item is toggled and the other items are left alone. Multiple items can be toggled by dragging the mouse over them.3 - When the user selects an item in the usual way, the selection is cleared and the new item selected. However, if the user presses the Ctrl key when clicking on an item, the clicked item gets toggled and all other items are left untouched. If the user presses the Shift key while clicking on an item, all items between the current item and the clicked item are selected or unselected, depending on the state of the clicked item. Multiple items can be selected by dragging the mouse over them.4 - When the user selects an item in the usual way, the selection is cleared and the new item selected. However, if the user presses the Shift key while clicking on an item, all items between the current item and the clicked item are selected or unselected, depending on the state of the clicked item.
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setSortEnabled(self, val='True', **kwargs):
        """
        enable scriptTable sorted by column default value is false and the whole row will be sorted                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setUseDoubleClickEdit(self, val='True', **kwargs):
        """
        this controls the cell edit modeFalse: Click in the cell to select (in Row selection, the last cell of the row is edited, in Column selection, the last cell of the column is edited)(default) True:  Clicked in cell is edited when double-clicked only                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries the script table control.
        
        Flags:
        - afterCellChangedCmd : acc      (script)        [create,edit]
            Sets the script to call after the value of a cell has been changed. The
            procedure is called with 2 integer arguments specifying the row and column for
            which the value was changed. The 3rd argument is the string which was entered
            into that cell. The procedure does not need to return any value. The row and
            column numbers passed in are 1-based (i.e. (1,1) is the upper left cell). The
            procedure should be of the form: global proc procedureName(int $row, int
            $column, string $value)
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - cellBackgroundColorCommand : cbc (script)        [create,edit]
            Sets the script to call when it requires the background color of a cell. The
            procedure is called with 2 integer arguments specifying the row and column for
            which the value is required. The procedure should return an array of ints which
            is the RGB color value for the cell. The row and column numbers passed in are
            1-based (i.e. (1,1) is the upper left cell). The procedure should be of the
            form: global proc int[] procedureName(int $row, int $column) { return {255,0,0};
            // return Red as cell background color }
        
        - cellChangedCmd : ccc           (script)        [create,edit]
            Sets the script to call when somebody has changed the value of a cell. The
            procedure is called with 2 integer arguments specifying the row and column for
            which the value was changed. The 3rd argument is the string which was entered
            into that cell. The procedure should return an integer value which indicates
            whether that value should be accepted (return 1 if yes, and 0 if no). The row
            and column numbers passed in are 1-based (i.e. (1,1) is the upper left cell).
            The procedure should be of the form: global proc int procedureName(int $row, int
            $column, string $value)
        
        - cellForegroundColorCommand : cfc (script)        [create,edit]
            Sets the script to call when it requires the foreground color of a cell. The
            procedure is called with 2 integer arguments specifying the row and column for
            which the value is required. The procedure should return an array of ints which
            is the RGB color value for the cell. The row and column numbers passed in are
            1-based (i.e. (1,1) is the upper left cell). The procedure should be of the
            form: global proc int[] procedureName(int $row, int $column) { return {0,0,0};
            // return Black as Text color }
        
        - cellIndex : ci                 (int, int)      [query,edit]
            used with cellValue , to give the index of row and column This flag and its
            argument must be passed to the command before the -q flag (see examples).
        
        - cellValue : cv                 (unicode)       [query,edit]
            query and set the cell value on the table by the index of row and column
            referred in flag -cellIndex.In edit mode, if flag -multiEditEnabled is True and
            any cell is selected, the flag -cellIndex is not used and the selected cells
            will be changed.
        
        - clearRow : cr                  (int)           [edit]
            Clear the contents for all the cells on the specified row. Any procedure
            specified by the -gcc flag will be called to populate the cleared cells The row
            number is 1-based (i.e. the first row is 1 not 0).
        
        - clearTable : ct                (bool)          [edit]
            Clears the contents of all the cells in the table. Any procedure specified by
            the -gcc flag will be called to populate the cleared cells
        
        - columnFilter : cf              (int, unicode)  [create,edit]
            Filter the specified column with the string value provided. Set filter to
            columns 0 will apply the filter to all columns. The filter is case insensitive
            and support wildcards. Wildcard Matching: Wildcard matching is much simpler than
            full regexps and has only four features: c    Any character represents itself
            apart from those mentioned below. Thus c matches the character c. ?     Matches
            any single character. It is the same as . in full regexps. \*   Matches zero or
            more of any characters. It is the same as .\* in full regexps. [...]    Sets of
            characters can be represented in square brackets, similar to full regexps.
            Within the character class, backslash has no special meaning. (i.e. you can
            search for MyValuewith y\*uor ??Val??or [MyThe]Valueor any letters in MyValueThe
            column number is 1-based (i.e. the first row is 1 not 0).
        
        - columnWidth : cw               (int, int)      [create,edit]
            Set the width of the specified column The column number is 1-based (ie. the
            first column is 1 not 0).
        
        - columns : c                    (int)           [create,query,edit]
            Set the number of columns in the table
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteRow : dr                 (int)           [edit]
            Delete the specified row The row number is 1-based (i.e. the first row is 1 not
            0).
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the table. By default, this flag is set to true, and the table
            can be edited. If false, then the table is 'read only' and cannot be typed into.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - excludingHeaders : eh          (bool)          [query]
            when querying the count for the rows or the columns , the number returned will
            not include the headers
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - getCellCmd : gcc               (script)        [create,edit]
            Sets the script to call when it requires the contents of a cell. The procedure
            is called with 2 integer arguments specifying the row and column for which the
            value is required. The procedure should return a string which is the value for
            the cell. The row and column numbers passed in are 1-based (ie. (1,1) is the
            upper left cell). The procedure should be of the form: global proc string
            procedureName(int $row, int $column)
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - insertRow : ir                 (int)           [edit]
            Insert an empty row before the specified row. Any procedure specified by the
            -gcc flag will be called to populate the new new cells. The row number is
            1-based (i.e. the first row is 1 not 0).
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (int, unicode)  [create,edit]
            Set the label of the specified column. The column number is 1-based (ie. the
            first column is 1 not 0).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - multiEditEnabled : mee         (bool)          [create,query,edit]
            True: scriptTable support multi-editing function
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowHeight : rh                 (int)           [create,query,edit]
            Sets the height for each row in the scriptTable
        
        - rows : r                       (int)           [create,query,edit]
            Set the number of rows in the table
        
        - rowsRemovedCmd : rrc           (script)        [create,edit]
            Sets the script to call after rows are removed by pressing 'delete' or
            'backspace' key. The procedure is called with one argument specifying that
            selected rows have been removed. The rows passed in are 1-based. The procedure
            should be of the form: global proc procedureName(int $rows[])
        
        - rowsToBeRemovedCmd : rtc       (script)        [create,edit]
            Sets the script to call when 'delete' or 'backspace' key is pressed. The
            procedure is called with one argument specifying the selected rows to be
            removed. The procedure should return an integer value which indicates whether
            the selected rows should be removed (return 1 if yes, and 0 if no). The rows
            passed in are 1-based. The procedure should be of the form: global proc int
            procedureName(int $rows[])
        
        - selectedCells : sc             (int)           [query,edit]
            Select the cells or return  the cells currently selected. This returns a list of
            indices, the first of each pair is the row, the second is the column, repeated
            for each cell selected The returned cell numbers are 1-based (ie. the first row
            is 1 not 0, the first column is 1 not 0).
        
        - selectedColumns : scs          (int)           [query,edit]
            select the columns or return the columns currently selected. This returns a list
            of indices of each column completely selected The returned column numbers are
            1-based
        
        - selectedRow : sr               (bool)          [query]
            The current row selected. The returned row number is 1-based (ie. the first row
            is 1 not 0).
        
        - selectedRows : srs             (int)           [query,edit]
            In edit mode, select the rows given as argument. In query mode, return a list of
            indices of completely selected rows. The row numbers are 1-based
        
        - selectionBehavior : sb         (int)           [create,query,edit]
            Set the selection behavior, valid values are from 0 to 2 (inclusive) 0 -
            Selecting single items. 1 - Selecting only rows. 2 - Selecting only columns.
        
        - selectionChangedCmd : scc      (script)        [create,edit]
            Sets the script to call when a complete selection operation triggered by the
            user has occurred successfully. The script does not pass any parameters and does
            not need to return any value (i.e. It is simply a notification mechanism).
        
        - selectionMode : sm             (int)           [create,query,edit]
            Set the selection Mode, valid values are from 0 to 4 (inclusive)0 - Items cannot
            be selected.1 - When the user selects an item, any already-selected item becomes
            unselected, and the user cannot unselect the selected item by clicking on it.2 -
            When the user selects an item in the usual way, the selection status of that
            item is toggled and the other items are left alone. Multiple items can be
            toggled by dragging the mouse over them.3 - When the user selects an item in the
            usual way, the selection is cleared and the new item selected. However, if the
            user presses the Ctrl key when clicking on an item, the clicked item gets
            toggled and all other items are left untouched. If the user presses the Shift
            key while clicking on an item, all items between the current item and the
            clicked item are selected or unselected, depending on the state of the clicked
            item. Multiple items can be selected by dragging the mouse over them.4 - When
            the user selects an item in the usual way, the selection is cleared and the new
            item selected. However, if the user presses the Shift key while clicking on an
            item, all items between the current item and the clicked item are selected or
            unselected, depending on the state of the clicked item.
        
        - sortEnabled : se               (bool)          [create,query,edit]
            enable scriptTable sorted by column default value is false and the whole row
            will be sorted
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - underPointerColumn : upc       (bool)          [query]
            The column under the pointer. The returned column number is 1-based (i.e. the
            first column is 1 not 0).
        
        - underPointerRow : upr          (bool)          [query]
            The row under the pointer. The returned row number is 1-based (i.e. the first
            row is 1 not 0).
        
        - useDoubleClickEdit : udc       (bool)          [create,query,edit]
            this controls the cell edit modeFalse: Click in the cell to select (in Row
            selection, the last cell of the row is edited, in Column selection, the last
            cell of the column is edited)(default) True:  Clicked in cell is edited when
            double-clicked only
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.scriptTable`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'scriptTable'
    
    
    __melui__ = 'scriptTable'


class IconTextCheckBox(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getAlign(self, **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getChangeCommand(self, **kwargs):
        """
        Command executed when the control's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the control from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getDisabledImage(self, **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getFlat(self, **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getFlipX(self, **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getFlipY(self, **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getHighlightImage(self, **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getImage(self, **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getImage1(self, **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getImage2(self, **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getImage3(self, **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getImageOverlayLabel(self, **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getLabelOffset(self, **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getMarginHeight(self, **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getMarginWidth(self, **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getOffCommand(self, **kwargs):
        """
        Command executed when the control is turned off.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getOnCommand(self, **kwargs):
        """
        Command executed when the control is turned on.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getOverlayLabelBackColor(self, **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getOverlayLabelColor(self, **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getRotation(self, **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getSelectionHighlightImage(self, **kwargs):
        """
        Image displayed while the control is selected and the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getSelectionImage(self, **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getStyle(self, **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getUseAlpha(self, **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getValue(self, **kwargs):
        """
        Sets or returns the state of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center. By default, the label is aligned center. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setChangeCommand(self, val='True', **kwargs):
        """
        Command executed when the control's state is changed. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of the control from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setDisabledImage(self, val='True', **kwargs):
        """
        Image used when the button is disabled. Image size must be the same as the image specified with the i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setFlat(self, val='True', **kwargs):
        """
        Sets whether the control will be a flat button (0 false, 1 true).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setFlipX(self, val='True', **kwargs):
        """
        Is the image flipped horizontally?                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setFlipY(self, val='True', **kwargs):
        """
        Is the image flipped vertically?                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setHighlightImage(self, val='True', **kwargs):
        """
        Highlight image displayed while the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        If you are not providing images with different sizes then you may use this flag for the control's image. If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setImage1(self, val='True', **kwargs):
        """
        First of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setImage2(self, val='True', **kwargs):
        """
        Second of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setImage3(self, val='True', **kwargs):
        """
        Third of three possible icons. The icon that best fits the current size of the control will be displayed.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setImageOverlayLabel(self, val='True', **kwargs):
        """
        A short string, up to 6 characters, representing a label that will be displayed on top of the image.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The text that appears in the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setLabelOffset(self, val='True', **kwargs):
        """
        The label offset. Default is 0. Currently only available when -st/style is set to iconAndTextCentered.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setMarginHeight(self, val='True', **kwargs):
        """
        The number of pixels above and below the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setMarginWidth(self, val='True', **kwargs):
        """
        The number of pixels on either side of the control content. The default value is 1 pixel.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setOffCommand(self, val='True', **kwargs):
        """
        Command executed when the control is turned off.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setOnCommand(self, val='True', **kwargs):
        """
        Command executed when the control is turned on.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setOverlayLabelBackColor(self, val='True', **kwargs):
        """
        The RGBA color of the shadow behind the label defined by imageOverlayLabel. Default is 50% transparent black: 0 0 0 .5                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setOverlayLabelColor(self, val='True', **kwargs):
        """
        The RGB color of the label defined by imageOverlayLabel. Default is a light grey: .8 .8 .8                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setRotation(self, val='True', **kwargs):
        """
        The rotation value of the image in radians.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setSelectionHighlightImage(self, val='True', **kwargs):
        """
        Image displayed while the control is selected and the cursor is over the control. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setSelectionImage(self, val='True', **kwargs):
        """
        Image displayed while the control is selected. Image size must be the same as the image specified with the -i/imageflag. This is a Windows only flag.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        The draw style of the control.  Valid styles are iconOnly, textOnly, iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note: iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set, the icon will be scaled to the size of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setUseAlpha(self, val='True', **kwargs):
        """
        Is the image using alpha channel?                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Sets or returns the state of the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this control feature was introduced. The argument should be given as a string of the version number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This control supports up to 3 icon images and 4 different display styles.  The
        icon image displayed is the one that best fits the current size of the control
        given its current style. This command creates an iconTextCheckBox.
        
        Flags:
        - align : al                     (unicode)       [create,query,edit]
            The label alignment.  Alignment values are left, right, and center. By default,
            the label is aligned center. Currently only available when -st/style is set to
            iconAndTextCentered.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,query,edit]
            Command executed when the control's state is changed. Note that this flag should
            not be used in conjunction with onCommand and offCommand. That is, one should
            either use changeCommand and test the state of the control from inside the
            callback, or use onCommand and offCommand as separate callbacks.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - disabledImage : di             (unicode)       [create,query,edit]
            Image used when the button is disabled. Image size must be the same as the image
            specified with the i/imageflag. This is a Windows only flag.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - flat : fla                     (bool)          [create,query,edit]
            Sets whether the control will be a flat button (0 false, 1 true).
        
        - flipX : fx                     (bool)          [create,query,edit]
            Is the image flipped horizontally?
        
        - flipY : fy                     (bool)          [create,query,edit]
            Is the image flipped vertically?
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - highlightImage : hi            (unicode)       [create,query,edit]
            Highlight image displayed while the cursor is over the control. Image size must
            be the same as the image specified with the -i/imageflag. This is a Windows only
            flag.
        
        - image : i                      (unicode)       [create,query,edit]
            If you are not providing images with different sizes then you may use this flag
            for the control's image. If the iconOnlystyle is set, the icon will be scaled to
            the size of the control.
        
        - image1 : i1                    (unicode)       [create,query,edit]
            First of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image2 : i2                    (unicode)       [create,query,edit]
            Second of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - image3 : i3                    (unicode)       [create,query,edit]
            Third of three possible icons. The icon that best fits the current size of the
            control will be displayed.
        
        - imageOverlayLabel : iol        (unicode)       [create,query,edit]
            A short string, up to 6 characters, representing a label that will be displayed
            on top of the image.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The text that appears in the control.
        
        - labelOffset : lo               (int)           [create,query,edit]
            The label offset. Default is 0. Currently only available when -st/style is set
            to iconAndTextCentered.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2013, 2014). Currently only accepts major version numbers (e.g.
            2013 Ext 1, or 2013.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - marginHeight : mh              (int)           [create,query,edit]
            The number of pixels above and below the control content. The default value is 1
            pixel.
        
        - marginWidth : mw               (int)           [create,query,edit]
            The number of pixels on either side of the control content. The default value is
            1 pixel.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - offCommand : ofc               (script)        [create,query,edit]
            Command executed when the control is turned off.
        
        - onCommand : onc                (script)        [create,query,edit]
            Command executed when the control is turned on.
        
        - overlayLabelBackColor : olb    (float, float, float, float) [create,query,edit]
            The RGBA color of the shadow behind the label defined by imageOverlayLabel.
            Default is 50% transparent black: 0 0 0 .5
        
        - overlayLabelColor : olc        (float, float, float) [create,query,edit]
            The RGB color of the label defined by imageOverlayLabel. Default is a light
            grey: .8 .8 .8
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rotation : rot                 (float)         [create,query,edit]
            The rotation value of the image in radians.
        
        - selectionHighlightImage : shi  (unicode)       [create,query,edit]
            Image displayed while the control is selected and the cursor is over the
            control. Image size must be the same as the image specified with the
            -i/imageflag. This is a Windows only flag.
        
        - selectionImage : si            (unicode)       [create,query,edit]
            Image displayed while the control is selected. Image size must be the same as
            the image specified with the -i/imageflag. This is a Windows only flag.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            The draw style of the control.  Valid styles are iconOnly, textOnly,
            iconAndTextHorizontal, iconAndTextVertical, and iconAndTextCentered. (Note:
            iconAndTextCenteredis only available on Windows). If the iconOnlystyle is set,
            the icon will be scaled to the size of the control.
        
        - useAlpha : ua                  (bool)          [create,query,edit]
            Is the image using alpha channel?
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (bool)          [create,query,edit]
            Sets or returns the state of the control.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this control feature was introduced. The argument
            should be given as a string of the version number (e.g. 2013, 2014). Currently
            only accepts major version numbers (e.g. 2013 Ext 1, or 2013.5 should be given
            as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.iconTextCheckBox`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'iconTextCheckBox'
    
    
    __melui__ = 'iconTextCheckBox'


class CmdScrollFieldReporter(PyUI):
    def clear(self, val='True', **kwargs):
        """
        Clears the field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def copySelection(self, val='True', **kwargs):
        """
        Copies the current selection from this field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def cutSelection(self, val='True', **kwargs):
        """
        Cuts the current selection from this field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getEchoAllCommands(self, **kwargs):
        """
        Echo all commands.    (Global parameter, affects all command reporters)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getFilterSourceType(self, **kwargs):
        """
        Filters the specified source type from showing in this command reporter. Currently supports either mel, python, or (default). Setting the filter to the empty string () will remove all filtering and show both meland pythonresults.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getHasFocus(self, **kwargs):
        """
        Whether this control is currently in focus.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getLineNumbers(self, **kwargs):
        """
        Show line numbers (in Error/Warning messages).    (Global parameter, affects all command reporters)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getStackTrace(self, **kwargs):
        """
        Show stack trace.    (Global parameter, affects all command reporters)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getSuppressErrors(self, **kwargs):
        """
        Suppress errors.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getSuppressInfo(self, **kwargs):
        """
        Suppress info.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getSuppressResults(self, **kwargs):
        """
        Suppress results.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getSuppressStackTrace(self, **kwargs):
        """
        Suppress stack trace.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getSuppressWarnings(self, **kwargs):
        """
        Suppress warnings.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getText(self, **kwargs):
        """
        Replaces the field text with the given string.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getTextLength(self, **kwargs):
        """
        The number of characters in this text field.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def pasteSelection(self, val='True', **kwargs):
        """
        Pastes text into this field at the current caret position.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def receiveFocusCommand(self, val='True', **kwargs):
        """
        Command executed when the field receives focus.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def saveSelection(self, val='True', **kwargs):
        """
        Prompts to save the current selection to a file. The default filename prompt will be prepended with the given string.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def saveSelectionToShelf(self, val='True', **kwargs):
        """
        Prompts to save the current selection to an item in the shelf.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def select(self, val='True', **kwargs):
        """
        Selects text within a specified range.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def selectAll(self, val='True', **kwargs):
        """
        Selects all text.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setEchoAllCommands(self, val='True', **kwargs):
        """
        Echo all commands.    (Global parameter, affects all command reporters)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setFilterSourceType(self, val='True', **kwargs):
        """
        Filters the specified source type from showing in this command reporter. Currently supports either mel, python, or (default). Setting the filter to the empty string () will remove all filtering and show both meland pythonresults.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setLineNumbers(self, val='True', **kwargs):
        """
        Show line numbers (in Error/Warning messages).    (Global parameter, affects all command reporters)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setStackTrace(self, val='True', **kwargs):
        """
        Show stack trace.    (Global parameter, affects all command reporters)                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setSuppressErrors(self, val='True', **kwargs):
        """
        Suppress errors.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setSuppressInfo(self, val='True', **kwargs):
        """
        Suppress info.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setSuppressResults(self, val='True', **kwargs):
        """
        Suppress results.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setSuppressStackTrace(self, val='True', **kwargs):
        """
        Suppress stack trace.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setSuppressWarnings(self, val='True', **kwargs):
        """
        Suppress warnings.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        Replaces the field text with the given string.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        A script editor reporter control used to receive and display the history of
        processed commmands.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - clear : clr                    (bool)          [create,edit]
            Clears the field.
        
        - copySelection : cp             (bool)          [create,edit]
            Copies the current selection from this field.
        
        - cutSelection : ct              (bool)          [create,edit]
            Cuts the current selection from this field.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - echoAllCommands : eac          (bool)          [create,query,edit]
            Echo all commands.    (Global parameter, affects all command reporters)
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - filterSourceType : fst         (unicode)       [create,query,edit]
            Filters the specified source type from showing in this command reporter.
            Currently supports either mel, python, or (default). Setting the filter to the
            empty string () will remove all filtering and show both meland pythonresults.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - hasFocus : hf                  (bool)          [query]
            Whether this control is currently in focus.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - lineNumbers : ln               (bool)          [create,query,edit]
            Show line numbers (in Error/Warning messages).    (Global parameter, affects all
            command reporters)
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - pasteSelection : pst           (bool)          [create,edit]
            Pastes text into this field at the current caret position.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - receiveFocusCommand : rfc      (script)        [create,edit]
            Command executed when the field receives focus.
        
        - saveSelection : sv             (unicode)       [create,edit]
            Prompts to save the current selection to a file. The default filename prompt
            will be prepended with the given string.
        
        - saveSelectionToShelf : svs     (bool)          [create,edit]
            Prompts to save the current selection to an item in the shelf.
        
        - select : sl                    (int, int)      [create,edit]
            Selects text within a specified range.
        
        - selectAll : sla                (bool)          [create,edit]
            Selects all text.
        
        - stackTrace : st                (bool)          [create,query,edit]
            Show stack trace.    (Global parameter, affects all command reporters)
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - suppressErrors : se            (bool)          [create,query,edit]
            Suppress errors.
        
        - suppressInfo : si              (bool)          [create,query,edit]
            Suppress info.
        
        - suppressResults : sr           (bool)          [create,query,edit]
            Suppress results.
        
        - suppressStackTrace : sst       (bool)          [create,query,edit]
            Suppress stack trace.
        
        - suppressWarnings : sw          (bool)          [create,query,edit]
            Suppress warnings.
        
        - text : t                       (unicode)       [create,query,edit]
            Replaces the field text with the given string.
        
        - textLength : tl                (bool)          [query]
            The number of characters in this text field.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.cmdScrollFieldReporter`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'cmdScrollFieldReporter'
    
    
    __melui__ = 'cmdScrollFieldReporter'


class Text(PyUI):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def dropRectCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is hovering above the drop site.  It returns the shape of the rectangle to be drawn to highlight the entry, if the control can receive the dropped data. The MEL version of the callback is of the form: global proc int[] callbackName(string $dropControl, int $x, int $y) The return value is an array of size 4, with the parameters, in order, being the left and top coordinates of the rectangle to be drawn, followed by the width and height. This functionality is currently only implemented in MEL.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getAlign(self, **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center.  Note that the alignment will only be noticable if the control is wider than the label length. By default, the label is aligned center.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getHyperlink(self, **kwargs):
        """
        Sets the label text to be a hyperlink if the argument is true.  The label text must be a proper HTML link. In MEL, double quotes in the link will most likely have to be protected from the MEL interpreter by preceding them with a backslash.  Clicking on the link will open it in an external Web browser.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The label text.  The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getRecomputeSize(self, **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def getWordWrap(self, **kwargs):
        """
        If true then label text is wrapped where necessary at word-breaks. If false, it is not wrapped at all. The default value of this flag is false.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setAlign(self, val='True', **kwargs):
        """
        The label alignment.  Alignment values are left, right, and center.  Note that the alignment will only be noticable if the control is wider than the label length. By default, the label is aligned center.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setHyperlink(self, val='True', **kwargs):
        """
        Sets the label text to be a hyperlink if the argument is true.  The label text must be a proper HTML link. In MEL, double quotes in the link will most likely have to be protected from the MEL interpreter by preceding them with a backslash.  Clicking on the link will open it in an external Web browser.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The label text.  The default label is the name of the control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setRecomputeSize(self, val='True', **kwargs):
        """
        If true then the control will recompute it's size to just fit the size of the label.  If false then the control size will remain fixed as you change the size of the label.  The default value of this flag is true.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a simple text label control.
        
        Flags:
        - align : al                     (unicode)       [create,query,edit]
            The label alignment.  Alignment values are left, right, and center.  Note that
            the alignment will only be noticable if the control is wider than the label
            length. By default, the label is aligned center.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - dropRectCallback : drc         (script)        [edit]
            Adds a callback that is called when a drag and drop operation is hovering above
            the drop site.  It returns the shape of the rectangle to be drawn to highlight
            the entry, if the control can receive the dropped data. The MEL version of the
            callback is of the form: global proc int[] callbackName(string $dropControl, int
            $x, int $y) The return value is an array of size 4, with the parameters, in
            order, being the left and top coordinates of the rectangle to be drawn, followed
            by the width and height. This functionality is currently only implemented in
            MEL.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the text.  Valid values are boldLabelFont, smallBoldLabelFont,
            tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont,
            smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - hyperlink : hl                 (bool)          [create,query,edit]
            Sets the label text to be a hyperlink if the argument is true.  The label text
            must be a proper HTML link. In MEL, double quotes in the link will most likely
            have to be protected from the MEL interpreter by preceding them with a
            backslash.  Clicking on the link will open it in an external Web browser.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            The label text.  The default label is the name of the control.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - recomputeSize : rs             (bool)          [create,query,edit]
            If true then the control will recompute it's size to just fit the size of the
            label.  If false then the control size will remain fixed as you change the size
            of the label.  The default value of this flag is true.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.
        
        - wordWrap : ww                  (bool)          [create,query]
            If true then label text is wrapped where necessary at word-breaks. If false, it
            is not wrapped at all. The default value of this flag is false.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.text`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'text'
    
    
    __melui__ = 'text'


class IntField(PyUI):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes.  This command is not invoked when the value changes via the -v/valueflag.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes by dragging the invisible slider.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def enterCommand(self, val='True', **kwargs):
        """
        Command executed when the keypad 'Enter' key is pressed.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The value of the field can always be changed with the -v/valueflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Upper limit of the field.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Lower limit of the field.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getStep(self, **kwargs):
        """
        Increment for the invisible slider.  The field value will change by this amount when the invisible slider is dragged.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the field.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def receiveFocusCommand(self, val='True', **kwargs):
        """
        Command executed when the field receives focus.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The value of the field can always be changed with the -v/valueflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Upper limit of the field.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Lower limit of the field.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Increment for the invisible slider.  The field value will change by this amount when the invisible slider is dragged.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the field.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a field control that accepts only integer values and is bound by a
        minimum and maximum value.  An invisible slider is attached to the field and
        accessed by holding down the Ctrl modifier key while pressing one of the mouse
        buttons.  Dragging the invisible slider to the right with the middle mouse
        button increases the field value by the amount specified with the -s/stepflag,
        while dragging to the left decreases the value by the same amount.  The left and
        right mouse buttons apply a factor of 0.1 and 10 to the step value.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the value changes.  This command is not invoked when the
            value changes via the -v/valueflag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command executed when the value changes by dragging the invisible slider.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the field.  By default, this flag is set to true and the field
            value may be changed by typing into it. If false then the field is 'read only'
            and can not be typed into. The value of the field can always be changed with the
            -v/valueflag regardless of the state of the -ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enterCommand : ec              (script)        [create,edit]
            Command executed when the keypad 'Enter' key is pressed.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (int)           [create,query,edit]
            Upper limit of the field.
        
        - minValue : min                 (int)           [create,query,edit]
            Lower limit of the field.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - receiveFocusCommand : rfc      (script)        [create,edit]
            Command executed when the field receives focus.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (int)           [create,query,edit]
            Increment for the invisible slider.  The field value will change by this amount
            when the invisible slider is dragged.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (int)           [create,query,edit]
            Value of the field.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.intField`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'intField'
    
    
    __melui__ = 'intField'


class ConfirmDialog(PyUI):
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        The confirmDialog command creates a modal dialog with a message to the user and
        a variable number of buttons to dismiss the dialog.  The dialog is dismissed
        when the user presses any button or chooses the close item from the window menu.
        In the case where a button is pressed then the name of the button selected is
        returned.  If the dialog is dismissed via the close item then the string
        returned is specified by the dismissStringflag. The default behaviour when no
        arguments are specified is to create an empty single button dialog.
        
        Flags:
        - annotation : ann               (unicode)       [create]
            set the annotation for the buttons
        
        - backgroundColor : bgc          (float, float, float) [create]
            The background color of the dialog. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
            (Windows only flag)
        
        - button : b                     (unicode)       [create]
            Create a button with the given string as it's text.
        
        - cancelButton : cb              (unicode)       [create]
            The cancel button is activated by pressing the escape key. Note that this flag
            does not create a button, it simply indicates which button created via the
            buttonflag shall respond to the escape key.
        
        - defaultButton : db             (unicode)       [create]
            The default button is activated by pressing the enter key. Note that this flag
            does not create a button, it simply indicates which button created via the
            buttonflag shall respond to the enter key.
        
        - dismissString : ds             (unicode)       [create]
            The string returned when the user selects the 'Close' item from the Window
            Manager menu.  If this flag is not set then the string dismissis returned.
        
        - icon : icn                     (unicode)       [create]
            The user can specify one of the four standard icons -- question, information,
            warningand critical.  The question icon indicates that the messsage is asking a
            question.  The information icon indicates that the message is nothing out of the
            ordinary.  The warning icon indicates that the message is a warning, but can be
            dealt with.  The critical icon indicates that the message represents a critical
            problem. When no icon flag is present, we assume the user does not want to
            include any icon in the confirm dialog.
        
        - message : m                    (unicode)       [create]
            The message text appearing in the dialog.
        
        - messageAlign : ma              (unicode)       [create]
            Align the message left, center, or right.
        
        - parent : p                     (unicode)       [create]
            Specify the parent window for the dialog.  The dialog will be centered on this
            window and raise and lower with it's parent. By default, the dialog is not
            parented to a particular window and is simply centered on the screen.
        
        - title : t                      (unicode)       [create]
            The dialog title.                  Flag can have multiple arguments, passed
            either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.confirmDialog`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'confirmDialog'
    
    
    __melui__ = 'confirmDialog'


class FloatSlider2(PyUI):
    def changeCommand1(self, val='True', **kwargs):
        """
        Command to be associated with handle 1 and issued whenever the value of the handle is changed (except when values are changed via the -hv/handleValue flag). An example command might be setAttr nurbsSphere1.txand if handle 1 were to move to value 0.23 the slider would issue the command setAttr nurbsSphere1.tx 0.23;.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def changeCommand2(self, val='True', **kwargs):
        """
        Command to be associated with handle 2 and issued whenever the value of the handle is changed (except when values are changed via the -hv/handleValue flag). An example command might be setAttr nurbsSphere1.txand if handle 2 were to move to value 0.23 the slider would issue the command setAttr nurbsSphere1.tx 0.23;.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getMaximum(self, **kwargs):
        """
        Maximum limit of the slider. The default value is 10.0. The maximum value occurs at the top(right) end of the slider unless -polarity was specified. Note: you cannot set the maximum value greater than or equal to the current minimum.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getMinimum(self, **kwargs):
        """
        Minimum limit of the slider. The default value is 0.0. The minimum value occurs at the bottom end of the slider unless -polarity was specified. Note: you cannot set the minimum value greater than or equal to the current maximum.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getPolarity(self, **kwargs):
        """
        Specifies the polarity of the slider. If 0 (the default), the minimum value (specified by the -minimum flag) occurs at the bottom end of the slider and maximum at the top(right), with values increasing as the slider handles are moved towards the upper end of the slider. If the polarity is specified as 1, the reverse behaviour occurs, with the maximum occurring at the bottom end, the mimimum occuring at the top(right) end and values decreasing as the handles are moved towards the upper end.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getValue1(self, **kwargs):
        """
        Value of handle 1. To ensure that handle 1 stays at or below handle 2, an error will occur if the value specified is too large. If you wish to set both handles simultaneously, use the -values flag.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getValue2(self, **kwargs):
        """
        Value of handle 2. To ensure that handle 2 stays at or above handle 2, an error will occur if the value specified is too large. If you wish to set both handles simultaneously, use the -values flag.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def positionControl1(self, val='True', **kwargs):
        """
        Set the name of the control (if any) which is associated with handle 1 of this slider. The control must be a floatField. The control always displays the value of the handle, and is updated as the handle moves.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def positionControl2(self, val='True', **kwargs):
        """
        Set the name of the control (if any) which is associated with handle 2 of this slider. The control must be a floatField. The control always displays the value of the handle, and is updated as the handle moves.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setMaximum(self, val='True', **kwargs):
        """
        Maximum limit of the slider. The default value is 10.0. The maximum value occurs at the top(right) end of the slider unless -polarity was specified. Note: you cannot set the maximum value greater than or equal to the current minimum.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setMinimum(self, val='True', **kwargs):
        """
        Minimum limit of the slider. The default value is 0.0. The minimum value occurs at the bottom end of the slider unless -polarity was specified. Note: you cannot set the minimum value greater than or equal to the current maximum.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setPolarity(self, val='True', **kwargs):
        """
        Specifies the polarity of the slider. If 0 (the default), the minimum value (specified by the -minimum flag) occurs at the bottom end of the slider and maximum at the top(right), with values increasing as the slider handles are moved towards the upper end of the slider. If the polarity is specified as 1, the reverse behaviour occurs, with the maximum occurring at the bottom end, the mimimum occuring at the top(right) end and values decreasing as the handles are moved towards the upper end.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setValue1(self, val='True', **kwargs):
        """
        Value of handle 1. To ensure that handle 1 stays at or below handle 2, an error will occur if the value specified is too large. If you wish to set both handles simultaneously, use the -values flag.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setValue2(self, val='True', **kwargs):
        """
        Value of handle 2. To ensure that handle 2 stays at or above handle 2, an error will occur if the value specified is too large. If you wish to set both handles simultaneously, use the -values flag.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    def values(self, val='True', **kwargs):
        """
        Sets the value for handles 1 and 2 simulteneously. The first argument is applied to handle 1 and must be less than or equal to the second (handle 2) argument or an error will be issued.                  
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a float slider containing two handles. The two handles are
        arranged such that they cannot pass one another, thus handle 1 will always have
        a value less than or or equal to handle 2 when you adjust the values. Each
        handle may have a MEL command associated with it which is issued when the handle
        moves and thus can be used to update the values of plugs such as via a setAttr
        command. Each handle can also be associated with a float textfield to display
        the current value of the handle. Note: the floatSlider2 widget currently only
        supports vertical (columnLayout) orientation.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand1 : cc1           (unicode)       [create,edit]
            Command to be associated with handle 1 and issued whenever the value of the
            handle is changed (except when values are changed via the -hv/handleValue flag).
            An example command might be setAttr nurbsSphere1.txand if handle 1 were to move
            to value 0.23 the slider would issue the command setAttr nurbsSphere1.tx 0.23;.
        
        - changeCommand2 : cc2           (unicode)       [create,edit]
            Command to be associated with handle 2 and issued whenever the value of the
            handle is changed (except when values are changed via the -hv/handleValue flag).
            An example command might be setAttr nurbsSphere1.txand if handle 2 were to move
            to value 0.23 the slider would issue the command setAttr nurbsSphere1.tx 0.23;.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maximum : max                  (float)         [create,query,edit]
            Maximum limit of the slider. The default value is 10.0. The maximum value occurs
            at the top(right) end of the slider unless -polarity was specified. Note: you
            cannot set the maximum value greater than or equal to the current minimum.
        
        - minimum : min                  (float)         [create,query,edit]
            Minimum limit of the slider. The default value is 0.0. The minimum value occurs
            at the bottom end of the slider unless -polarity was specified. Note: you cannot
            set the minimum value greater than or equal to the current maximum.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - polarity : pol                 (int)           [create,query,edit]
            Specifies the polarity of the slider. If 0 (the default), the minimum value
            (specified by the -minimum flag) occurs at the bottom end of the slider and
            maximum at the top(right), with values increasing as the slider handles are
            moved towards the upper end of the slider. If the polarity is specified as 1,
            the reverse behaviour occurs, with the maximum occurring at the bottom end, the
            mimimum occuring at the top(right) end and values decreasing as the handles are
            moved towards the upper end.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - positionControl1 : pc1         (unicode)       [create,edit]
            Set the name of the control (if any) which is associated with handle 1 of this
            slider. The control must be a floatField. The control always displays the value
            of the handle, and is updated as the handle moves.
        
        - positionControl2 : pc2         (unicode)       [create,edit]
            Set the name of the control (if any) which is associated with handle 2 of this
            slider. The control must be a floatField. The control always displays the value
            of the handle, and is updated as the handle moves.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value1 : v1                    (float)         [create,query,edit]
            Value of handle 1. To ensure that handle 1 stays at or below handle 2, an error
            will occur if the value specified is too large. If you wish to set both handles
            simultaneously, use the -values flag.
        
        - value2 : v2                    (float)         [create,query,edit]
            Value of handle 2. To ensure that handle 2 stays at or above handle 2, an error
            will occur if the value specified is too large. If you wish to set both handles
            simultaneously, use the -values flag.
        
        - values : vs                    (float, float)  [create,edit]
            Sets the value for handles 1 and 2 simulteneously. The first argument is applied
            to handle 1 and must be less than or equal to the second (handle 2) argument or
            an error will be issued.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.floatSlider2`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'floatSlider2'
    
    
    __melui__ = 'floatSlider2'


class BlendShapePanel(Panel):
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getBlendShapeEditor(self, **kwargs):
        """
        Query only flag that returns the name of an editor to be associated with the panel.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a panel that derives from the base panel class that houses
        a blendShapeEditor.
        
        Flags:
        - blendShapeEditor : be          (bool)          [query]
            Query only flag that returns the name of an editor to be associated with the
            panel.
        
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.blendShapePanel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'blendShapePanel'
    
    
    __melui__ = 'blendShapePanel'


class Window(PyUIContainer):
    """
    pymel window class
    """
    
    
    
    def __exit__(self, type, value, traceback): pass
    def asQtObject(mayaName):
        """
        Given the name of a May UI control, return the corresponding QWidget.
        If the object does not exist, returns None
        
        .. note:: Requires PySide
        """
        pass
    def backgroundColor(self, val='True', **kwargs):
        """
        The background color of the window. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def children(self): pass
    def closeCommand(self, val='True', **kwargs):
        """
        Script executed after the window is closed.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def delete(self): pass
    def getChildren(self): pass
    def getDocTag(self, **kwargs):
        """
        Attach a tag to the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getDockingLayout(self, **kwargs):
        """
        When queried this flag will return a string holding the docking layout information. This string can be set when creating or editing a docking station to restore the previous docking layout. This string is a hexadecimal representation of a binary string and is not meant to be humanly readable, but can be saved and loaded using the optionVar command to restore layouts across sessions of Maya.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getFrontWindow(self, **kwargs):
        """
        Return the name of the front window.  Note: you must supply the name of any window (the window does not need to exist). Returns unknownif the front window cannot be determined.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getHeight(self, **kwargs):
        """
        Height of the window excluding any window frame in pixels.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getIconName(self, **kwargs):
        """
        The window's icon title.  By default it is the same as the window's title.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getIconify(self, **kwargs):
        """
        Icon state of the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getLeftEdge(self, **kwargs):
        """
        Position of the left edge of the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMainMenuBar(self, **kwargs):
        """
        If this flag is used then the main menu bar will be enabled.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMainWindow(self, **kwargs):
        """
        Main window for the application.  The main window has an 'Exit' item in the Window Manager menu.  By default, the first created window becomes the main window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMaximizeButton(self, **kwargs):
        """
        Turns the window's maximize button on or off.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMenuArray(self, **kwargs):
        """
        Return a string array containing the names of the menus in the window's menu bar.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMenuBar(self, **kwargs):
        """
        Adds an empty menu bar to the window. The Qt name of the object will be m_menubar_nameOfTheWindow.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMenuBarCornerWidget(self, **kwargs):
        """
        This flag specifies a widget to add to a corner of the parent window. The first argument corresponds to the widget name and the second to the position of the widget. Possible values for widget position are topLeft, topRight, bottomLeft, bottomRight. In query mode this flag returns all the corner widget names in the following order: topLeft, topRight, bottomLeft, bottomRight. Add the -mbr/-menuBarResizeflag to the changeCommandof widget passed (first argument) so that it will always have an appropriate size.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Visibility of the menu bar (if there is one).                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getMinimizeButton(self, **kwargs):
        """
        Turns the window's minimize button on or off.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getNumberOfMenus(self, **kwargs):
        """
        Return the number of menus attached to the window's menu bar.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getParent(self): pass
    def getResizeToFitChildren(self, **kwargs):
        """
        The window will always grow/shrink to just fit the controls it contains.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getSizeable(self, **kwargs):
        """
        Whether or not the window may be interactively resized.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getState(self, **kwargs):
        """
        When queried this flag will return a string holding the window state information. This string is a hexadecimal representation of a binary string and is not meant to be humanly readable, but can be saved and loaded using the optionVar command to restore window state across sessions of Maya.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getTitle(self, **kwargs):
        """
        The window's title.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getTitleBar(self, **kwargs):
        """
        Turns the window's title bar on or off.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getTitleBarMenu(self, **kwargs):
        """
        Controls whether the title bar menu exists in the window title bar. Only valid if -tb/titleBaris true. This Windows only flag is true by default.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getToolbox(self, **kwargs):
        """
        Makes this a toolbox style window.  A Windows only flag that makes the title bar smaller and uses a slightly different display style.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getTopEdge(self, **kwargs):
        """
        Position of the top edge of the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getTopLeftCorner(self, **kwargs):
        """
        Position of the window's top left corner.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The window's visibility.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getWidth(self, **kwargs):
        """
        Width of the window excluding any window frame in pixels.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def getWidthHeight(self, **kwargs):
        """
        Window's width and height excluding any window frame in pixels.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def layout(self): pass
    def menuBarResize(self, val='True', **kwargs):
        """
        This flag should be used with the -mcw/-menuBarCornerWidgetflag. This is used to resize the menu bar so that the corner widgets are updated.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def menuIndex(self, val='True', **kwargs):
        """
        Sets the index of a specified menu.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def minimizeCommand(self, val='True', **kwargs):
        """
        Script executed after the window is minimized (iconified).                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def parent(self): pass
    def restoreCommand(self, val='True', **kwargs):
        """
        Script executed after the window is restored from it's minimized (iconified) state.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attach a tag to the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setDockingLayout(self, val='True', **kwargs):
        """
        When queried this flag will return a string holding the docking layout information. This string can be set when creating or editing a docking station to restore the previous docking layout. This string is a hexadecimal representation of a binary string and is not meant to be humanly readable, but can be saved and loaded using the optionVar command to restore layouts across sessions of Maya.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        Height of the window excluding any window frame in pixels.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setIconName(self, val='True', **kwargs):
        """
        The window's icon title.  By default it is the same as the window's title.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setIconify(self, val='True', **kwargs):
        """
        Icon state of the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setLeftEdge(self, val='True', **kwargs):
        """
        Position of the left edge of the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setMainMenuBar(self, val='True', **kwargs):
        """
        If this flag is used then the main menu bar will be enabled.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setMainWindow(self, val='True', **kwargs):
        """
        Main window for the application.  The main window has an 'Exit' item in the Window Manager menu.  By default, the first created window becomes the main window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setMaximizeButton(self, val='True', **kwargs):
        """
        Turns the window's maximize button on or off.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setMenuBarCornerWidget(self, val='True', **kwargs):
        """
        This flag specifies a widget to add to a corner of the parent window. The first argument corresponds to the widget name and the second to the position of the widget. Possible values for widget position are topLeft, topRight, bottomLeft, bottomRight. In query mode this flag returns all the corner widget names in the following order: topLeft, topRight, bottomLeft, bottomRight. Add the -mbr/-menuBarResizeflag to the changeCommandof widget passed (first argument) so that it will always have an appropriate size.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Visibility of the menu bar (if there is one).                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setMinimizeButton(self, val='True', **kwargs):
        """
        Turns the window's minimize button on or off.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setResizeToFitChildren(self, val='True', **kwargs):
        """
        The window will always grow/shrink to just fit the controls it contains.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setSizeable(self, val='True', **kwargs):
        """
        Whether or not the window may be interactively resized.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setState(self, val='True', **kwargs):
        """
        When queried this flag will return a string holding the window state information. This string is a hexadecimal representation of a binary string and is not meant to be humanly readable, but can be saved and loaded using the optionVar command to restore window state across sessions of Maya.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setTitle(self, val='True', **kwargs):
        """
        The window's title.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setTitleBar(self, val='True', **kwargs):
        """
        Turns the window's title bar on or off.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setTitleBarMenu(self, val='True', **kwargs):
        """
        Controls whether the title bar menu exists in the window title bar. Only valid if -tb/titleBaris true. This Windows only flag is true by default.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setToolbox(self, val='True', **kwargs):
        """
        Makes this a toolbox style window.  A Windows only flag that makes the title bar smaller and uses a slightly different display style.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setTopEdge(self, val='True', **kwargs):
        """
        Position of the top edge of the window.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setTopLeftCorner(self, val='True', **kwargs):
        """
        Position of the window's top left corner.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The window's visibility.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        Width of the window excluding any window frame in pixels.                  
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def setWidthHeight(self, val='True', **kwargs):
        """
        Window's width and height excluding any window frame in pixels.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    def show(self): pass
    def window(self): pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a new window but leaves it invisible. It is most efficient
        to add the window's elements and then make it visible with the showWindow
        command. The window can have an optional menu bar. Also, the title bar and
        minimize/maximize buttons can be turned on or off. If the title bar is off, then
        you cannot have minimize or maximize buttons. Note: The window will require a
        control layout of some kind to arrange the controls (buttons, sliders, fields,
        etc.).  Examples of control layouts are columnLayout, formLayout, rowLayout,
        etc. Note: This command will clear the uiTemplate stack.  Templates for a window
        need to be set after the window cmd.
        
        Flags:
        - backgroundColor : bgc          (float, float, float) [create,edit]
            The background color of the window. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - closeCommand : cc              (script)        [create,edit]
            Script executed after the window is closed.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attach a tag to the window.
        
        - dockCorner : dc                (unicode, unicode) [create]
            Specifies which docking areas occupied the four different corners of the window.
            By default docking windows on the bottom or top will span the whole window. Use
            multiple instances of this flag to allow the left and right docking areas to
            occupy the corners. This method has two arguments: docking corner and docking
            area. Possible values for docking corner are topLeft, topRight, bottomLeft, and
            bottomRight. Possible values for docking area are left, right, top, and bottom.
        
        - dockStation : ds               (bool)          [create]
            When set this flag specifies that this window can contain other docked sub-
            windows.
        
        - dockingLayout : dl             (unicode)       [create,query,edit]
            When queried this flag will return a string holding the docking layout
            information. This string can be set when creating or editing a docking station
            to restore the previous docking layout. This string is a hexadecimal
            representation of a binary string and is not meant to be humanly readable, but
            can be saved and loaded using the optionVar command to restore layouts across
            sessions of Maya.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - frontWindow : fw               (bool)          [query]
            Return the name of the front window.  Note: you must supply the name of any
            window (the window does not need to exist). Returns unknownif the front window
            cannot be determined.
        
        - height : h                     (int)           [create,query,edit]
            Height of the window excluding any window frame in pixels.
        
        - iconName : iconName            (unicode)       [create,query,edit]
            The window's icon title.  By default it is the same as the window's title.
        
        - iconify : i                    (bool)          [create,query,edit]
            Icon state of the window.
        
        - interactivePlacement : ip      (bool)          [create]
            Deprecated flag. Recognized but not implemented. This flag will be removed in a
            future version of Maya.
        
        - leftEdge : le                  (int)           [create,query,edit]
            Position of the left edge of the window.
        
        - mainMenuBar : mm               (bool)          [create,query,edit]
            If this flag is used then the main menu bar will be enabled.
        
        - mainWindow : mw                (bool)          [create,query,edit]
            Main window for the application.  The main window has an 'Exit' item in the
            Window Manager menu.  By default, the first created window becomes the main
            window.
        
        - maximizeButton : mxb           (bool)          [create,query,edit]
            Turns the window's maximize button on or off.
        
        - menuArray : ma                 (bool)          [query]
            Return a string array containing the names of the menus in the window's menu
            bar.
        
        - menuBar : mb                   (bool)          [create,query]
            Adds an empty menu bar to the window. The Qt name of the object will be
            m_menubar_nameOfTheWindow.
        
        - menuBarCornerWidget : mcw      (unicode, unicode) [query,edit]
            This flag specifies a widget to add to a corner of the parent window. The first
            argument corresponds to the widget name and the second to the position of the
            widget. Possible values for widget position are topLeft, topRight, bottomLeft,
            bottomRight. In query mode this flag returns all the corner widget names in the
            following order: topLeft, topRight, bottomLeft, bottomRight. Add the
            -mbr/-menuBarResizeflag to the changeCommandof widget passed (first argument) so
            that it will always have an appropriate size.
        
        - menuBarResize : mbr            (bool)          [edit]
            This flag should be used with the -mcw/-menuBarCornerWidgetflag. This is used to
            resize the menu bar so that the corner widgets are updated.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Visibility of the menu bar (if there is one).
        
        - menuIndex : mi                 (unicode, int)  [edit]
            Sets the index of a specified menu.
        
        - minimizeButton : mnb           (bool)          [create,query,edit]
            Turns the window's minimize button on or off.
        
        - minimizeCommand : mnc          (script)        [create,edit]
            Script executed after the window is minimized (iconified).
        
        - nestedDockingEnabled : nde     (bool)          [create]
            Controls whether nested docking is enabled or not.  Nested docking allows for
            docking windows next to other docked windows for more possible arrangement
            styles.
        
        - numberOfMenus : nm             (bool)          [query]
            Return the number of menus attached to the window's menu bar.
        
        - parent : p                     (unicode)       [create]
            Specifies a parent window or layout which the created window is always on top
            of. Note: If the parent is a window the created window is not modal, so events
            are still propagated to the parent window.
        
        - resizeToFitChildren : rtf      (bool)          [create,query,edit]
            The window will always grow/shrink to just fit the controls it contains.
        
        - restoreCommand : rc            (script)        [create,edit]
            Script executed after the window is restored from it's minimized (iconified)
            state.
        
        - retain : ret                   (bool)          [create]
            Retains the window after it has been closed.  The default is to delete the
            window when it is closed.
        
        - sizeable : s                   (bool)          [create,query,edit]
            Whether or not the window may be interactively resized.
        
        - state : st                     (unicode)       [create,query,edit]
            When queried this flag will return a string holding the window state
            information. This string is a hexadecimal representation of a binary string and
            is not meant to be humanly readable, but can be saved and loaded using the
            optionVar command to restore window state across sessions of Maya.
        
        - title : t                      (unicode)       [create,query,edit]
            The window's title.
        
        - titleBar : tb                  (bool)          [create,query,edit]
            Turns the window's title bar on or off.
        
        - titleBarMenu : tbm             (bool)          [create,query,edit]
            Controls whether the title bar menu exists in the window title bar. Only valid
            if -tb/titleBaris true. This Windows only flag is true by default.
        
        - toolbox : tlb                  (bool)          [create,query,edit]
            Makes this a toolbox style window.  A Windows only flag that makes the title bar
            smaller and uses a slightly different display style.
        
        - topEdge : te                   (int)           [create,query,edit]
            Position of the top edge of the window.
        
        - topLeftCorner : tlc            (int, int)      [create,query,edit]
            Position of the window's top left corner.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The window's visibility.
        
        - width : w                      (int)           [create,query,edit]
            Width of the window excluding any window frame in pixels.
        
        - widthHeight : wh               (int, int)      [create,query,edit]
            Window's width and height excluding any window frame in pixels.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.window`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'window'
    
    
    __melui__ = 'window'


class HardwareRenderPanel(Panel):
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getCamera(self, **kwargs):
        """
        Query or edit the camera in a gl render panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getGlRenderEditor(self, **kwargs):
        """
        Query only. This flag returns the name of the gl render editor contained in the panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setCamera(self, val='True', **kwargs):
        """
        Query or edit the camera in a gl render panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates, edit and queries hardware render panels which contain only
        a hardware render editor.
        
        Flags:
        - camera : cam                   (unicode)       [query,edit]
            Query or edit the camera in a gl render panel.
        
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - glRenderEditor : gre           (bool)          [query]
            Query only. This flag returns the name of the gl render editor contained in the
            panel.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.hardwareRenderPanel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'hardwareRenderPanel'
    
    
    __melui__ = 'hardwareRenderPanel'


class DynRelEdPanel(Panel):
    __melui__ = 'dynRelEdPanel'


class SubMenuItem(Menu):
    def asQtObject(mayaName):
        """
        Given the name of a Maya UI menuItem, return the corresponding QAction.
        If the object does not exist, returns None
        
        This only works for menu items. for Menus, use toQtControl or toQtObject
        
        .. note:: Requires PySide
        """
        pass
    def getBoldFont(self): pass
    def getItalicized(self): pass


class HyperPanel(Panel):
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getHyperEditor(self, **kwargs):
        """
        This flag returns the name of the hypergraph editor contained by the panel.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates, edit and queries hypergraph panels which contain only a
        hypergraph editor.
        
        Flags:
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - hyperEditor : he               (bool)          [query]
            This flag returns the name of the hypergraph editor contained by the panel.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.hyperPanel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'hyperPanel'
    
    
    __melui__ = 'hyperPanel'


class Layout(PyUIContainer):
    def asQtObject(mayaName):
        """
        Given the name of a May UI control, return the corresponding QWidget.
        If the object does not exist, returns None
        
        .. note:: Requires PySide
        """
        pass
    def children(self):
        """
        Returns
        -------
        List[PyUI]
        """
        pass
    def clear(self): pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getChildren(self):
        """
        Returns
        -------
        List[PyUI]
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command allows you to edit or query the properties of any layout. The
        argument is the name of the layout.           In query mode, return type is
        based on queried flag.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.layout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'layout'
    
    
    __melui__ = 'layout'


class ModelPanel(Panel):
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getBarLayout(self, **kwargs):
        """
        This flag returns the name of the layout which is the parent of the panels icon bar.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getCamera(self, **kwargs):
        """
        Query or edit the camera in a modelPanel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getModelEditor(self, **kwargs):
        """
        This flag returns the name of the model editor contained by the panel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setCamera(self, val='True', **kwargs):
        """
        Query or edit the camera in a modelPanel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a panel consisting of a model editor. See the
        modelEditorcommand documentation for more information.
        
        Flags:
        - addTab : at                    (unicode)       []
        
        - barLayout : bl                 (bool)          [query]
            This flag returns the name of the layout which is the parent of the panels icon
            bar.
        
        - camera : cam                   (unicode)       [query,edit]
            Query or edit the camera in a modelPanel.
        
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - modelEditor : me               (bool)          [query]
            This flag returns the name of the model editor contained by the panel.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - removeTab : rt                 (unicode)       []
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - selectTab : st                 (unicode)       []
        
        - tabCommand : tc                (unicode, unicode) []
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.modelPanel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'modelPanel'
    
    
    __melui__ = 'modelPanel'


class OutlinerPanel(Panel):
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getOutlinerEditor(self, **kwargs):
        """
        This flag returns the name of the outliner editor contained by the panel.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates, edit and queries outliner panels which contain only an
        outliner editor.
        
        Flags:
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - outlinerEditor : oe            (bool)          [query]
            This flag returns the name of the outliner editor contained by the panel.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.outlinerPanel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'outlinerPanel'
    
    
    __melui__ = 'outlinerPanel'


class ScriptedPanel(Panel):
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def getType(self, **kwargs):
        """
        This flag specifies the type of scripted panel to create.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command will create an instance of the specified scriptedPanelType. A panel
        is a collection of UI objects (buttons, fields, graphical views) that are
        grouped together. A panel can be moved around as a group within the application
        interface, and torn off to exist in its own window. The panel takes care of
        maintaining the state of its UI when it is relocated, or recreated. A scripted
        panel is a panel that is defined in MEL, with all of the required callbacks
        available as MEL proc's.
        
        Flags:
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - type : typ                     (unicode)       [create,query]
            This flag specifies the type of scripted panel to create.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.scriptedPanel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'scriptedPanel'
    
    
    __melui__ = 'scriptedPanel'


class MainProgressBar(ProgressBar):
    """
    Context manager for main progress bar
    
    If an exception occur after beginProgress() but before endProgress() maya
    gui becomes unresponsive. Use this class to escape this behavior.
    
    Here's an example::
    
        with MainProgressBar(0,20,True) as bar:
            bar.setStatus('Calculating...')
            for i in range(0,20):
                bar.setProgress(i)
                if bar.getIsCancelled():
                    break
    """
    
    
    
    def __enter__(self): pass
    def __exit__(self, *args): pass
    @staticmethod
    def __new__(cls, minValue='0', maxValue='100', interruptable='True'):
        """
        Parameters
        ----------
        minValue : int
            Minimum or startingvalue of progress indicatior. If the progress
            value is less than the minValue, the progress value will be set
            to the minimum.  Default value is 0
        maxValue : int
            The maximum or endingvalue of the progress indicator. If the
            progress value is greater than the maxValue, the progress value
            will be set to the maximum. Default value is 100.
        interruptable : bool
            Set to True if the isCancelled flag should respond to attempts to
            cancel the operation. Setting this to true will put make the help
            line display message to the user indicating that they can cancel
            the operation.
        """
        pass


class PopupMenu(Menu):
    def deleteAllItems(self, val='True', **kwargs):
        """
        Delete all the items in this menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getAllowOptionBoxes(self, **kwargs):
        """
        Indicate whether the menu will be able to support option box menu items.  An error results if an option box item is added to a menu that doesn't allow them.  This flag may be queried and must be specified when the popup menu is created.  The default value is false.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getAltModifier(self, **kwargs):
        """
        Specify this flag if the Alt modifier must be pressed when posting the popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getButton(self, **kwargs):
        """
        Indicate which button posts the popup menu.  Valid values range from 1 to 3 where 1 is the left most button on the mouse.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getCtrlModifier(self, **kwargs):
        """
        Specify this flag if the Cntl modifier must be pressed when posting the popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getMarkingMenu(self, **kwargs):
        """
        Set the marking menu state of this popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getNumberOfItems(self, **kwargs):
        """
        Return number of items in the menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getPostMenuCommandOnce(self, **kwargs):
        """
        Indicate the -pmc/postMenuCommandshould only be invoked once.  Default value is false, ie. the -pmc/postMenuCommandis invoked every time the popup menu is shown.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def getShiftModifier(self, **kwargs):
        """
        Specify this flag if the Shift modifier must be pressed when posting the popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def postMenuCommand(self, val='True', **kwargs):
        """
        Specify a script to be executed when the popup menu is about to be shown.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def setAltModifier(self, val='True', **kwargs):
        """
        Specify this flag if the Alt modifier must be pressed when posting the popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def setButton(self, val='True', **kwargs):
        """
        Indicate which button posts the popup menu.  Valid values range from 1 to 3 where 1 is the left most button on the mouse.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def setCtrlModifier(self, val='True', **kwargs):
        """
        Specify this flag if the Cntl modifier must be pressed when posting the popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def setMarkingMenu(self, val='True', **kwargs):
        """
        Set the marking menu state of this popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def setPostMenuCommandOnce(self, val='True', **kwargs):
        """
        Indicate the -pmc/postMenuCommandshould only be invoked once.  Default value is false, ie. the -pmc/postMenuCommandis invoked every time the popup menu is shown.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    def setShiftModifier(self, val='True', **kwargs):
        """
        Specify this flag if the Shift modifier must be pressed when posting the popup menu.                  
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a popup menu and attaches it to the current control if no
        parent is specified.  The popup menu is posted with the right mouse button by
        default. Popup menus can be added to any kind of control, however, on some
        widgets, only the standard menu button (3rd mouse button) can be used to trigger
        popup menus. This is to meet generally accepted UI guidelines that assign the
        3rd mouse button and only this one to popup menus, and also to prevent
        unexpected behavior of controls like text fields, that expect 1st and 2nd button
        to be reserved for contextual operations like text or item selection...
        
        Flags:
        - allowOptionBoxes : aob         (bool)          [create,query]
            Indicate whether the menu will be able to support option box menu items.  An
            error results if an option box item is added to a menu that doesn't allow them.
            This flag may be queried and must be specified when the popup menu is created.
            The default value is false.
        
        - altModifier : alt              (bool)          [create,query,edit]
            Specify this flag if the Alt modifier must be pressed when posting the popup
            menu.
        
        - button : b                     (int)           [create,query,edit]
            Indicate which button posts the popup menu.  Valid values range from 1 to 3
            where 1 is the left most button on the mouse.
        
        - ctrlModifier : ctl             (bool)          [create,query,edit]
            Specify this flag if the Cntl modifier must be pressed when posting the popup
            menu.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteAllItems : dai           (bool)          [edit]
            Delete all the items in this menu.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - itemArray : ia                 (bool)          [query]
            Return string array of the menu item names.
        
        - markingMenu : mm               (bool)          [create,query,edit]
            Set the marking menu state of this popup menu.
        
        - numberOfItems : ni             (bool)          [query]
            Return number of items in the menu.
        
        - parent : p                     (unicode)       [create]
            Specify the control that the popup menu will appear in.
        
        - postMenuCommand : pmc          (script)        [create,edit]
            Specify a script to be executed when the popup menu is about to be shown.
        
        - postMenuCommandOnce : pmo      (bool)          [create,query,edit]
            Indicate the -pmc/postMenuCommandshould only be invoked once.  Default value is
            false, ie. the -pmc/postMenuCommandis invoked every time the popup menu is
            shown.
        
        - shiftModifier : sh             (bool)          [create,query,edit]
            Specify this flag if the Shift modifier must be pressed when posting the popup
            menu.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.popupMenu`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'popupMenu'
    
    
    __melui__ = 'popupMenu'


class DevicePanel(Panel):
    def copy(self, val='True', **kwargs):
        """
        Makes this panel a copy of the specified panel.  Both panels must be of the same type.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def createString(self, val='True', **kwargs):
        """
        Command string used to create a panel                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def editString(self, val='True', **kwargs):
        """
        Command string used to edit a panel                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getControl(self, **kwargs):
        """
        Returns the top level control for this panel. Usually used for getting a parent to attach popup menus. CAUTION: panels may not have controls at times.  This flag can return if no control is present.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getIsUnique(self, **kwargs):
        """
        Returns true if only one instance of this panel type is allowed.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getMenuBarRepeatLast(self, **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getNeedsInit(self, **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getPopupMenuProcedure(self, **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def getTearOff(self, **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def init(self, val='True', **kwargs):
        """
        Initializes the panel's default state.  This is usually done automatically on file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def replacePanel(self, val='True', **kwargs):
        """
        Will replace the specified panel with this panel.  If the target panel is within the same layout it will perform a swap.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Attaches a tag to the Maya panel.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Specifies the user readable label for the panel.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def setMenuBarRepeatLast(self, val='True', **kwargs):
        """
        Controls whether clicking on the menu header with the middle mouse button would repeat the last selected menu item.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Controls whether the menu bar for the panel is displayed.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def setNeedsInit(self, val='True', **kwargs):
        """
        (Internal) On Edit will mark the panel as requiring initialization. Query will return whether the panel is marked for initialization.  Used during file -new and file -open.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def setPopupMenuProcedure(self, val='True', **kwargs):
        """
        Specifies the procedure called for building the panel's popup menu(s). The default value is buildPanelPopupMenu.  The procedure should take one string argument which is the panel's name.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def setTearOff(self, val='True', **kwargs):
        """
        Will tear off this panel into a separate window with a paneLayout as the parent of the panel. When queried this flag will return if the panel has been torn off into its own window.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def tearOffRestore(self, val='True', **kwargs):
        """
        Restores panel if it is torn off and focus is given to it. If docked, becomes the active panel in the docked window. This should be the default flag that is added to all panels instead of -to/-tearOffflag which should only be used to tear off the panel.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    def unParent(self, val='True', **kwargs):
        """
        Specifies that the panel should be removed from its layout. This (obviously) cannot be used with query.                  
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command is now obsolete. It is included only for the purpose of file
        compatibility. It creates a blank panel.
        
        Flags:
        - control : ctl                  (bool)          [query]
            Returns the top level control for this panel. Usually used for getting a parent
            to attach popup menus. CAUTION: panels may not have controls at times.  This
            flag can return if no control is present.
        
        - copy : cp                      (unicode)       [edit]
            Makes this panel a copy of the specified panel.  Both panels must be of the same
            type.
        
        - createString : cs              (bool)          [edit]
            Command string used to create a panel
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Attaches a tag to the Maya panel.
        
        - editString : es                (bool)          [edit]
            Command string used to edit a panel
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - init : init                    (bool)          [create,edit]
            Initializes the panel's default state.  This is usually done automatically on
            file -new and file -open.
        
        - isUnique : iu                  (bool)          [query]
            Returns true if only one instance of this panel type is allowed.
        
        - label : l                      (unicode)       [query,edit]
            Specifies the user readable label for the panel.
        
        - menuBarRepeatLast : mrl        (bool)          [create,query,edit]
            Controls whether clicking on the menu header with the middle mouse button would
            repeat the last selected menu item.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Controls whether the menu bar for the panel is displayed.
        
        - needsInit : ni                 (bool)          [query,edit]
            (Internal) On Edit will mark the panel as requiring initialization. Query will
            return whether the panel is marked for initialization.  Used during file -new
            and file -open.
        
        - parent : p                     (unicode)       [create]
            Specifies the parent layout for this panel.
        
        - popupMenuProcedure : pmp       (script)        [query,edit]
            Specifies the procedure called for building the panel's popup menu(s). The
            default value is buildPanelPopupMenu.  The procedure should take one string
            argument which is the panel's name.
        
        - replacePanel : rp              (unicode)       [edit]
            Will replace the specified panel with this panel.  If the target panel is within
            the same layout it will perform a swap.
        
        - tearOff : to                   (bool)          [query,edit]
            Will tear off this panel into a separate window with a paneLayout as the parent
            of the panel. When queried this flag will return if the panel has been torn off
            into its own window.
        
        - tearOffCopy : toc              (unicode)       [create]
            Will create this panel as a torn of copy of the specified source panel.
        
        - tearOffRestore : tor           (bool)          [create,edit]
            Restores panel if it is torn off and focus is given to it. If docked, becomes
            the active panel in the docked window. This should be the default flag that is
            added to all panels instead of -to/-tearOffflag which should only be used to
            tear off the panel.
        
        - unParent : up                  (bool)          [edit]
            Specifies that the panel should be removed from its layout. This (obviously)
            cannot be used with query.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.devicePanel`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'devicePanel'
    
    
    __melui__ = 'devicePanel'


class RowColumnLayout(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Alignment for text and pixmaps in the specified column.  Values are: left, rightand center.  Only valid for column format, ie. number of columns specified with -nc/numberOfColumnsflag.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        The attachments and offsets for the children in the specified column.  The first argument is the 1-based column index.  The second argument is the attachment, valid values are left, rightand both.  The third argument must be greater than 0 and specifies the offset.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def columnOffset(self, val='True', **kwargs):
        """
        The attachment offset for the specified column.  The first argument is the 1-based column index.  The second argument is the attachment, valid values are left, rightand both.  The third argument must be greater than 0 and specifies the offset.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def columnSpacing(self, val='True', **kwargs):
        """
        The space between columns in pixels.  In column format this flag specifies that the space be to the left of the given column.  In row format it specifies the space between all columns, however a valid column index is still required.  The first argument is the 1-based column index.  The second argument must be greater than 0 and specifies the spacing.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Width of a column. This flag is valid only in column format.  The column width must be greater than 0.  The first argument is the 1-based column index.  The second argument must be greater than 0 and specifies the column width.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getNumberOfColumns(self, **kwargs):
        """
        Number of columns. This flag is mutually exclusive to the -nr/numRowsflag.  Either one or the other can be specified.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getNumberOfRows(self, **kwargs):
        """
        Number of rows. This flag is mutually exclusive to the -nc/numColumnsflag. Either one or the other can be specified.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def rowAlign(self, val='True', **kwargs):
        """
        Alignment for text and pixmaps in the specified row. Values are: left, rightand center.  Only valid for row format, ie. number of rows specified with -nr/numberOfRowsflag.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        The attachments and offsets for the children in the specified row.  The first argument is the 1-based row index.  The second argument is the attachment, valid values are top, bottomand both.  The third argument must be greater than 0 and specifies the offset.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def rowHeight(self, val='True', **kwargs):
        """
        Height of a row. This flag is only valid in row format. The row height must be greater than 0. The first argument is the 1-based row index.  The second argument must be greater than 0 and specifies the row height.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def rowOffset(self, val='True', **kwargs):
        """
        The attachment offset for the specified row.  The first argument is the 1-based row index.  The second argument is the attachment, valid values are top, bottomand both.  The third argument must be greater than 0 and specifies the offset.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def rowSpacing(self, val='True', **kwargs):
        """
        The space between rows, in pixels.  In row format this specifies the space above the specified row.  In column format it specifies the space between all rows, however a valid row index is still required.  The first argument is the 1-based row index.  The second argument must be greater than 0 and specifies the spacing.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a rowColumn layout. A rowColumn layout positions children
        in either a row or column format. A column layout, specified with the
        -nc/numberOfColumnsflag, allows you set text alignment, attachments and offsets
        for each column in the layout. Every member of a column will have the same
        alignment, attachment and offsets.  Likewise the row format, specified by the
        -nr/numberOfRowsflag, allows setting of these attributes for each row in the
        layout. Every member of a row will have the same attributes. The layout must be
        either a row or column format. This layout does not support both, or the
        specification of attributes on an individual child basis. Some flags only make
        sense for one of either the row format or the column format.  For example the
        -rh/rowHeightflag can only be specified in row format. In column format the row
        height is determined by the tallest child in the row, plus offsets.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Alignment for text and pixmaps in the specified column.  Values are: left,
            rightand center.  Only valid for column format, ie. number of columns specified
            with -nc/numberOfColumnsflag.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            The attachments and offsets for the children in the specified column.  The first
            argument is the 1-based column index.  The second argument is the attachment,
            valid values are left, rightand both.  The third argument must be greater than 0
            and specifies the offset.
        
        - columnOffset : co              (int, unicode, int) [create,edit]
            The attachment offset for the specified column.  The first argument is the
            1-based column index.  The second argument is the attachment, valid values are
            left, rightand both.  The third argument must be greater than 0 and specifies
            the offset.
        
        - columnSpacing : cs             (int, int)      [create,edit]
            The space between columns in pixels.  In column format this flag specifies that
            the space be to the left of the given column.  In row format it specifies the
            space between all columns, however a valid column index is still required.  The
            first argument is the 1-based column index.  The second argument must be greater
            than 0 and specifies the spacing.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Width of a column. This flag is valid only in column format.  The column width
            must be greater than 0.  The first argument is the 1-based column index.  The
            second argument must be greater than 0 and specifies the column width.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfColumns : nc           (int)           [create,query]
            Number of columns. This flag is mutually exclusive to the -nr/numRowsflag.
            Either one or the other can be specified.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - numberOfRows : nr              (int)           [create,query]
            Number of rows. This flag is mutually exclusive to the -nc/numColumnsflag.
            Either one or the other can be specified.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAlign : ral                 (int, unicode)  [create,edit]
            Alignment for text and pixmaps in the specified row. Values are: left, rightand
            center.  Only valid for row format, ie. number of rows specified with
            -nr/numberOfRowsflag.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            The attachments and offsets for the children in the specified row.  The first
            argument is the 1-based row index.  The second argument is the attachment, valid
            values are top, bottomand both.  The third argument must be greater than 0 and
            specifies the offset.
        
        - rowHeight : rh                 (int, int)      [create,edit]
            Height of a row. This flag is only valid in row format. The row height must be
            greater than 0. The first argument is the 1-based row index.  The second
            argument must be greater than 0 and specifies the row height.
        
        - rowOffset : ro                 (int, unicode, int) [create,edit]
            The attachment offset for the specified row.  The first argument is the 1-based
            row index.  The second argument is the attachment, valid values are top,
            bottomand both.  The third argument must be greater than 0 and specifies the
            offset.
        
        - rowSpacing : rs                (int, int)      [create,edit]
            The space between rows, in pixels.  In row format this specifies the space above
            the specified row.  In column format it specifies the space between all rows,
            however a valid row index is still required.  The first argument is the 1-based
            row index.  The second argument must be greater than 0 and specifies the
            spacing.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.rowColumnLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'rowColumnLayout'
    
    
    __melui__ = 'rowColumnLayout'


class AttrEnumOptionMenuGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def attribute(self, val='True', **kwargs):
        """
        The name of an attribute.  The button will be attached to the attribute so the button can be kept in synch with the attribute.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Text for the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Text for the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of label and option menu button
        associated with an attribute of a node. The attribute should be an integer, and
        this control allows a UI association of strings to the integers of the
        attribute. When a new menu item is choosen the corresponding integer will be
        assigned to the attribute. This control will automatically read the enumeration
        values from the attribute if none are provided.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attribute : at                 (PyNode)        [create,edit]
            The name of an attribute.  The button will be attached to the attribute so the
            button can be kept in synch with the attribute.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - enumeratedItem : ei            (int, unicode)  [create]
            Enumerated item and the corresponding string. If this flag is not supplied when
            the control is created, then the command will try to read the values from the
            attribute.
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Text for the control.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attrEnumOptionMenuGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attrEnumOptionMenuGrp'
    
    
    __melui__ = 'attrEnumOptionMenuGrp'


class IntSliderGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        The command string executed when the value of the slider changes.  It will be executed only once after a drag of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        The command string executed repeatedly during a drag of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be an extra label appearing after the slider.  Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getFieldMaxValue(self, **kwargs):
        """
        Maximum value that may be entered in the field.  This value may be set to any value greater than the -max/maxValueflag.  By default, it is equal to the -max/maxValueflag.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getFieldMinValue(self, **kwargs):
        """
        Minimum value that may be entered in the field.  This value may be set to any value less than the -min/minValueflag.  By default, it is equal to the -min/minValueflag.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getFieldStep(self, **kwargs):
        """
        Increment for the field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        If present on creation the group will have static text. Returns a string on query.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Sets the maximum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Sets the minimum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getSliderStep(self, **kwargs):
        """
        On Linux the slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getStep(self, **kwargs):
        """
        Increment for both the slider and field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the group.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be an extra label appearing after the slider.  Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setFieldMaxValue(self, val='True', **kwargs):
        """
        Maximum value that may be entered in the field.  This value may be set to any value greater than the -max/maxValueflag.  By default, it is equal to the -max/maxValueflag.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setFieldMinValue(self, val='True', **kwargs):
        """
        Minimum value that may be entered in the field.  This value may be set to any value less than the -min/minValueflag.  By default, it is equal to the -min/minValueflag.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setFieldStep(self, val='True', **kwargs):
        """
        Increment for the field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        If present on creation the group will have static text. Returns a string on query.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Sets the maximum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Sets the minimum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setSliderStep(self, val='True', **kwargs):
        """
        On Linux the slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Increment for both the slider and field.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the group.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of controls containing a label text,
        an integer field and an integer slider. The text and field controls are
        optional.  Editing or querying the field range values has no effect if the
        -f/fieldflag was not specified when the group was created. This group also
        allows you to enter values into the field outside of the slider range which is
        limited by the -min/minValueand -max/maxValueflags.  To do this, use the
        -fmn/fieldMinValueand -fmx/fieldMaxValueflags to specify a greater range of
        values. Note that the command will not allow you to specify a
        -fmn/fieldMinValuegreater than the -min/minValuevalue nor a
        -fmx/fieldMaxValueless than the -max/maxValuevalue. If you do supply a larger
        field range with the -fmn/fieldMinValueand -fmx/fieldMaxValueflags then you will
        notice that entering a value in the field that is outside of the slider range
        will result in extending the slider range as well.  For example, if you create a
        slider group with the following command: intSliderGrp -min -10 -max 10
        -fieldMinValue -100 -fieldMaxValue 100; Then you will be able to use the slider
        to select any value from -10 to 10. At the same time you will be able to enter
        into the field any value from -100 to 100.  If you enter a value, say 20, then
        the new slider range will grow such that this value is now accessible through
        the slider as well.  In fact, the new slider limit will become double of that
        what you entered.  Note that the slider limits will never grow beyond the field
        limits, in other words if you entered the value 80 then the slider will be
        clipped to the field limit of 100 and not doubled to 160. TelfBaseGrpCmd.cpp
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            The command string executed when the value of the slider changes.  It will be
            executed only once after a drag of the slider.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            The command string executed repeatedly during a drag of the slider.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            If present on creation this specifies that there will be an extra label
            appearing after the slider.  Sets the string to be the text for the extra label.
        
        - field : f                      (bool)          [create]
            If true on creation the group will have an editable int field present that
            reflects the value of the slider.
        
        - fieldMaxValue : fmx            (int)           [create,query,edit]
            Maximum value that may be entered in the field.  This value may be set to any
            value greater than the -max/maxValueflag.  By default, it is equal to the
            -max/maxValueflag.
        
        - fieldMinValue : fmn            (int)           [create,query,edit]
            Minimum value that may be entered in the field.  This value may be set to any
            value less than the -min/minValueflag.  By default, it is equal to the
            -min/minValueflag.
        
        - fieldStep : fs                 (int)           [create,query,edit]
            Increment for the field.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            If present on creation the group will have static text. Returns a string on
            query.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (int)           [create,query,edit]
            Sets the maximum value for both the slider and the field.
        
        - minValue : min                 (int)           [create,query,edit]
            Sets the minimum value for both the slider and the field.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - sliderStep : ss                (int)           [create,query,edit]
            On Linux the slider step value represents the amount the value will increase or
            decrease when you click either side of the slider.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (int)           [create,query,edit]
            Increment for both the slider and field.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (int)           [create,query,edit]
            Value of the group.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.intSliderGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'intSliderGrp'
    
    
    __melui__ = 'intSliderGrp'


class RowLayout(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Text alignment for the specified column. Valid values are left, right, and center
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Horizontally attach a particular column.  The first argument is a 1-based index specifying the column.  The second argument is the attachment, valid values are left, right, and both.  The third argument is the offset value.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Width of a particular column.  The first argument is a 1-based index specifying the column.  The second argument is the width value.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getNumberOfColumns(self, **kwargs):
        """
        Number of columns in the row.  The specified number of columns must be a value greater than 0.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Vertically attach a particular column.  The first argument is a 1-based index specifying the column.  The second argument is the attachment, valid values are top, bottom, and both.  The third argument is the offset value.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a layout capable of positioning children into a single
        horizontal row.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.
        
        - adjustableColumn1 : ad1        (int)           [create]
            Specifies that the first column has an adjustable size that changes with the
            size of the parent layout. Ignored if there isn't exactly one column.
        
        - adjustableColumn2 : ad2        (int)           [create]
            Specifies which of the two columns has an adjustable size that changes with the
            size of the parent layout. Ignored if there isn't exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create]
            Specifies which of the three columns has an adjustable size that changes with
            the size of the parent layout. Ignored if there isn't exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create]
            Specifies which of the four columns has an adjustable size that changes with the
            size of the parent layout. Ignored if there isn't exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create]
            Specifies which of the five columns has an adjustable size that changes with the
            size of the parent layout. Ignored if there isn't exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create]
            Specifies which of the six columns has an adjustable size that changes with the
            size of the parent layout. Ignored if there isn't exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Text alignment for the specified column. Valid values are left, right, and
            center
        
        - columnAlign1 : cl1             (unicode)       [create]
            Text alignment for the first column. Valid values are left, right, and center.
            Ignored if there isn't exactly one column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create]
            Text alignment for both columns. Valid values are left, right, and center.
            Ignored if there isn't exactly two columns.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create]
            Text alignment for all three columns. Valid values are left, right, and center.
            Ignored if there isn't exactly three columns.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create]
            Text alignment for all four columns. Valid values are left, right, and center.
            Ignored if there isn't exactly four columns.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create]
            Text alignment for all five columns. Valid values are left, right, and center.
            Ignored if there isn't exactly five columns.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create]
            Text alignment for all six columns. Valid values are left, right, and center.
            Ignored if there isn't exactly six columns.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Horizontally attach a particular column.  The first argument is a 1-based index
            specifying the column.  The second argument is the attachment, valid values are
            left, right, and both.  The third argument is the offset value.
        
        - columnAttach1 : ct1            (unicode)       [create]
            Attachment type for the first column.  Ignored if there isn't exactly one
            column. Valid values are left, right, and both.
        
        - columnAttach2 : ct2            (unicode, unicode) [create]
            Attachment type for both columns.  Ignored if there isn't exactly two columns.
            Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create]
            Attachment type for all three columns.  Ignored if there isn't exactly three
            columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create]
            Attachment type for all four columns.  Ignored if there isn't exactly four
            columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create]
            Attachment type for all five columns.  Ignored if there isn't exactly five
            columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create]
            Attachment type for all six columns.  Ignored if there isn't exactly six
            columns. Valid values are left, right, and both.
        
        - columnOffset1 : co1            (int)           [create]
            Used in conjunction with the -columnAttach1 flag.  If that flag is not used then
            this flag will be ignored.  Sets the offset for the first column.  The offsets
            applied are based on the attachments specified with the -columnAttach1 flag.
            Ignored if there isn't exactly one column.
        
        - columnOffset2 : co2            (int, int)      [create]
            Used in conjunction with the -columnAttach2 flag.  If that flag is not used then
            this flag will be ignored.  Sets the offset for both columns.  The offsets
            applied are based on the attachments specified with the -columnAttach2 flag.
            Ignored if there isn't exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create]
            Used in conjunction with the -columnAttach3 flag.  If that flag is not used then
            this flag will be ignored.  Sets the offset for all three columns.  The offsets
            applied are based on the attachments specified with the -columnAttach3 flag.
            Ignored if there isn't exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create]
            Used in conjunction with the -columnAttach4 flag.  If that flag is not used then
            this flag will be ignored.  Sets the offset for all four columns.  The offsets
            applied are based on the attachments specified with the -columnAttach4 flag.
            Ignored if there isn't exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create]
            Used in conjunction with the -columnAttach5 flag.  If that flag is not used then
            this flag will be ignored.  Sets the offset for all five columns.  The offsets
            applied are based on the attachments specified with the -columnAttach5 flag.
            Ignored if there isn't exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create]
            Used in conjunction with the -columnAttach6 flag.  If that flag is not used then
            this flag will be ignored.  Sets the offset for all six columns.  The offsets
            applied are based on the attachments specified with the -columnAttach6 flag.
            Ignored if there isn't exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Width of a particular column.  The first argument is a 1-based index specifying
            the column.  The second argument is the width value.
        
        - columnWidth1 : cw1             (int)           [create]
            Width for the first column.  Ignored if there isn't exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create]
            Widths for both columns.  Ignored if there isn't exactly two columns.
        
        - columnWidth3 : cw3             (int, int, int) [create]
            Widths for all three columns.  Ignored if there isn't exactly three columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create]
            Widths for all four columns.  Ignored if there isn't exactly four columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create]
            Widths for all five columns.  Ignored if there isn't exactly five columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create]
            Widths for all six columns.  Ignored if there isn't exactly six columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfColumns : nc           (int)           [create,query]
            Number of columns in the row.  The specified number of columns must be a value
            greater than 0.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Vertically attach a particular column.  The first argument is a 1-based index
            specifying the column.  The second argument is the attachment, valid values are
            top, bottom, and both.  The third argument is the offset value.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.rowLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'rowLayout'
    
    
    __melui__ = 'rowLayout'


class AttrControlGrp(Layout):
    def getAnnotation(self, **kwargs):
        """
        Sets or queries the annotation value of the control group.                                 
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        Sets or queries the attribute the control represents. The name of the attribute must be fully specified, including the name of the node. Some types of attributes are not supported, but most commonly used attribute types are.                                   
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getChangeCommand(self, **kwargs):
        """
        Sets or queries the change command of the control group. The change command will be executed when the control is used to change the value of the attribute.                                
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        Sets or queries the enable state of the control group. The control is dimmed if the enable state is set to false.                                  
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getExists(self, **kwargs):
        """
        Returns whether the specified object exists or not. Other flags are ignored.                               
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getHandlesAttribute(self, **kwargs):
        """
        Returns true or false as to whether this command can create a control for the specified attribute. 
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getHideMapButton(self, **kwargs):
        """
        Force the map button to remain hidden for this control.                                    
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Sets or queries the label of the control group.                                    
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        Sets or queries the prevent adjustment state of the control group. If true, the RMB menu for the control will not allow adjustments to be made.                                    Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Sets or queries the annotation value of the control group.                                 
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        Sets or queries the attribute the control represents. The name of the attribute must be fully specified, including the name of the node. Some types of attributes are not supported, but most commonly used attribute types are.                                   
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setChangeCommand(self, val='True', **kwargs):
        """
        Sets or queries the change command of the control group. The change command will be executed when the control is used to change the value of the attribute.                                
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        Sets or queries the enable state of the control group. The control is dimmed if the enable state is set to false.                                  
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setExists(self, val='True', **kwargs):
        """
        Returns whether the specified object exists or not. Other flags are ignored.                               
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setHandlesAttribute(self, val='True', **kwargs):
        """
        Returns true or false as to whether this command can create a control for the specified attribute. 
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setHideMapButton(self, val='True', **kwargs):
        """
        Force the map button to remain hidden for this control.                                    
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Sets or queries the label of the control group.                                    
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        Sets or queries the prevent adjustment state of the control group. If true, the RMB menu for the control will not allow adjustments to be made.                                    Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a control of the type most appropriate for the specified
        attribute, and associates the control with the attribute. Any change to the
        control will cause a change in the attribute value, and any change to the
        attribute value will be reflected in the control. Not all attribute types are
        supported.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Sets or queries the annotation value of the control group.
        
        - attribute : a                  (PyNode)        [create,query,edit]
            Sets or queries the attribute the control represents. The name of the attribute
            must be fully specified, including the name of the node. Some types of
            attributes are not supported, but most commonly used attribute types are.
        
        - changeCommand : cc             (script)        [create,query,edit]
            Sets or queries the change command of the control group. The change command will
            be executed when the control is used to change the value of the attribute.
        
        - enable : en                    (bool)          [create,query,edit]
            Sets or queries the enable state of the control group. The control is dimmed if
            the enable state is set to false.
        
        - exists : ex                    (bool)          [create,query,edit]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - handlesAttribute : ha          (PyNode)        [query,edit]
            Returns true or false as to whether this command can create a control for the
            specified attribute.
        
        - hideMapButton : hmb            (bool)          [create,query,edit]
            Force the map button to remain hidden for this control.
        
        - label : l                      (unicode)       [create,query,edit]
            Sets or queries the label of the control group.
        
        - preventOverride : po           (bool)          [create,query,edit]
            Sets or queries the prevent adjustment state of the control group. If true, the
            RMB menu for the control will not allow adjustments to be made.
            Flag can have multiple arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attrControlGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attrControlGrp'
    
    
    __melui__ = 'attrControlGrp'


class TextFieldGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the field text changes and user presses Enter or Return.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def forceChangeCommand(self, val='True', **kwargs):
        """
        If used together with -text or -inserText flag, change command will be executed after text modification.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/textflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getFileName(self, **kwargs):
        """
        Text in the field as a filename. This does conversions between internal and external (UI) file representation.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getInsertionPosition(self, **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getPlaceholderText(self, **kwargs):
        """
        Setting this property makes the line edit display a grayed-out placeholder text as long as the text field is empty and the widget doesn't have focus. By default, this property contains an empty string.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getText(self, **kwargs):
        """
        Text in the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def insertText(self, val='True', **kwargs):
        """
        Insert text into the field at the current insertion position (specified by the -ip/insertionPosition flag).                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/textflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setFileName(self, val='True', **kwargs):
        """
        Text in the field as a filename. This does conversions between internal and external (UI) file representation.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setInsertionPosition(self, val='True', **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setPlaceholderText(self, val='True', **kwargs):
        """
        Setting this property makes the line edit display a grayed-out placeholder text as long as the text field is empty and the widget doesn't have focus. By default, this property contains an empty string.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        Text in the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    def textChangedCommand(self, val='True', **kwargs):
        """
        Command executed immediately when the field text changes.                  
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of label text and editable text field.
        The label text is optional.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the field text changes and user presses Enter or Return.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the field.  By default, this flag is set to true and the field
            value may be changed by typing into it. If false then the field is 'read only'
            and can not be typed into. The text in the field can always be changed with the
            -tx/textflag regardless of the state of the -ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fileName : fi                  (unicode)       [create,query,edit]
            Text in the field as a filename. This does conversions between internal and
            external (UI) file representation.
        
        - forceChangeCommand : fcc       (bool)          [create,edit]
            If used together with -text or -inserText flag, change command will be executed
            after text modification.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - insertText : it                (unicode)       [create,edit]
            Insert text into the field at the current insertion position (specified by the
            -ip/insertionPosition flag).
        
        - insertionPosition : ip         (int)           [create,query,edit]
            The insertion position for inserted text.  This is a 1 based value where
            position 1 specifies the beginning of the field.  Position 0 may be used to
            specify the end of the field.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Label text for the group.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - placeholderText : pht          (unicode)       [create,query,edit]
            Setting this property makes the line edit display a grayed-out placeholder text
            as long as the text field is empty and the widget doesn't have focus. By
            default, this property contains an empty string.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - text : tx                      (unicode)       [create,query,edit]
            Text in the field.
        
        - textChangedCommand : tcc       (script)        [create,edit]
            Command executed immediately when the field text changes.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.textFieldGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'textFieldGrp'
    
    
    __melui__ = 'textFieldGrp'


class ColumnLayout(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Sets the children of the layout to be attached on both sides. They will stretch or shrink with the layout.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Sets the alignment of children containing text or pixmaps. Align values: left| right| center.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Sets the attachment and offsets for the children of the layout.  Side values: left| right| both.  Left or both is recommended.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def columnOffset(self, val='True', **kwargs):
        """
        Sets the offsets for children of the layout. Side values: left| right| both.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getColumnWidth(self, **kwargs):
        """
        Sets the width of the column.  Unless the children are attached to both sides of the column, the width cannot be enforced. Larger children will expand layout.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getRowSpacing(self, **kwargs):
        """
        Sets the space between children.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setColumnWidth(self, val='True', **kwargs):
        """
        Sets the width of the column.  Unless the children are attached to both sides of the column, the width cannot be enforced. Larger children will expand layout.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setRowSpacing(self, val='True', **kwargs):
        """
        Sets the space between children.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a layout that arranges its children in a single column.
        
        Flags:
        - adjustableColumn : adj         (bool)          [create,edit]
            Sets the children of the layout to be attached on both sides. They will stretch
            or shrink with the layout.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - columnAlign : cal              (unicode)       [create,edit]
            Sets the alignment of children containing text or pixmaps. Align values: left|
            right| center.
        
        - columnAttach : cat             (unicode, int)  [create,edit]
            Sets the attachment and offsets for the children of the layout.  Side values:
            left| right| both.  Left or both is recommended.
        
        - columnOffset : co              (unicode, int)  [create,edit]
            Sets the offsets for children of the layout. Side values: left| right| both.
        
        - columnWidth : cw               (int)           [create,query,edit]
            Sets the width of the column.  Unless the children are attached to both sides of
            the column, the width cannot be enforced. Larger children will expand layout.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowSpacing : rs                (int)           [create,query,edit]
            Sets the space between children.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.columnLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'columnLayout'
    
    
    __melui__ = 'columnLayout'


class ShelfTabLayout(Layout):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is selected interactively. This command is only invoked when the selected tab changes. Re-selecting the current tab will not invoke this command.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def doubleClickCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is double clicked on.  Note that the first click will select the tab and the second click will execute the double click command.  Double clicking the current tab will re-invoke the double click command.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getBorderStyle(self, **kwargs):
        """
        Specify the style of the border for tab layout. Valid values are: none, top, notopand full. By default, it will use fullto draw a simple frame around the body area of the tab layout. none- Do not draw borders around the body area of the tab layouttop- Only draw a simple line right below the tabsnotop- Draw a simple frame on the left/right/bottom (no top) of the tab layoutfull- Draw a simple frame around the body area of the tab layout
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getChildResizable(self, **kwargs):
        """
        Set to true if you want the child of the control layout to be as wide as the scroll area.  You may also indicate a minimum width for the child using the -mcw/minChildWidthflag.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getImage(self, **kwargs):
        """
        Image appearing in top right corner of tab layout.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getImageVisible(self, **kwargs):
        """
        Visibility of tab image.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getInnerMarginHeight(self, **kwargs):
        """
        Margin height for all tab children.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getInnerMarginWidth(self, **kwargs):
        """
        Margin width for all tab children.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getMinChildWidth(self, **kwargs):
        """
        Specify a positive non-zero integer value indicating the minimum width the tab layout's children.  This flag only has meaning when the -cr/childResizableflag is set to true.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getScrollable(self, **kwargs):
        """
        Puts all children of this layout within a scroll area.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getScrollableTabs(self, **kwargs):
        """
        If true, the active tab in the layout can be scrolled through with the mouse wheel. Default is true.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getSelectCommand(self, **kwargs):
        """
        Command executed when a tab is selected interactively  This command will be invoked whenever a tab is selected, ie. re-selecting the current tab will invoke this command.  Note that this command is not executed by using either of the -st/selectTabor -sti/selectTabIndexflags.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getSelectTab(self, **kwargs):
        """
        The name, in short form, of the selected tab.  An empty string is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getSelectTabIndex(self, **kwargs):
        """
        Identical to the -st/selectTabflag except this flag takes a 1-based index to identify the selected tab.  A value of 0 is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getShowNewTab(self, **kwargs):
        """
        Set to true if you want to have a 'New Tab' button shown at the end of the tab bar.  Note: use the -ntc/newTabCommandflag to set the command executed when this button is clicked.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getTabLabel(self, **kwargs):
        """
        Set a tab label.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the label for the tab associated with that child. If this flag is queried then the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getTabLabelIndex(self, **kwargs):
        """
        Identical to the -tl/tabLabelflag except this flag takes a 1-based index to identify the tab you want to set the label for. If this flag is queried the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getTabPosition(self, **kwargs):
        """
        Changes the tab position. The possible values are: north, eastand west.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getTabTooltip(self, **kwargs):
        """
        Set a tab tooltip.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the tooltip for the tab associated with that child. If this flag is queried then the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getTabTooltipIndex(self, **kwargs):
        """
        Identical to the -tt/tabTooltipflag except this flag takes a 1-based index to identify the tab you want to set the tooltip for. If this flag is queried the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getTabsClosable(self, **kwargs):
        """
        Set to true if you want to have a close button icon on all created tabs.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getTabsVisible(self, **kwargs):
        """
        Visibility of the tab labels.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def horizontalScrollBarThickness(self, val='True', **kwargs):
        """
        Thickness of the horizontal scroll bar.  Specify an integer value greater than or equal to zero. This flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def moveTab(self, val='True', **kwargs):
        """
        Move the tab from the current index to a new index.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def newTabCommand(self, val='True', **kwargs):
        """
        Command executed when the 'New Tab' button (on the tab bar) is clicked.  Note: in order to show the new tab button use the -snt/showNewTabflag.  Using this command will override any internal Maya logic for adding a new tab (only this command will be executed).                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def preSelectCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is selected but before it's contents become visible.  Re-selecting the current tab will not invoke this command.  Note that this command is not executed by using either of the -st/selectTabor -sti/selectTabIndexflags.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setBorderStyle(self, val='True', **kwargs):
        """
        Specify the style of the border for tab layout. Valid values are: none, top, notopand full. By default, it will use fullto draw a simple frame around the body area of the tab layout. none- Do not draw borders around the body area of the tab layouttop- Only draw a simple line right below the tabsnotop- Draw a simple frame on the left/right/bottom (no top) of the tab layoutfull- Draw a simple frame around the body area of the tab layout
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Image appearing in top right corner of tab layout.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setImageVisible(self, val='True', **kwargs):
        """
        Visibility of tab image.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setScrollableTabs(self, val='True', **kwargs):
        """
        If true, the active tab in the layout can be scrolled through with the mouse wheel. Default is true.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setSelectCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is selected interactively  This command will be invoked whenever a tab is selected, ie. re-selecting the current tab will invoke this command.  Note that this command is not executed by using either of the -st/selectTabor -sti/selectTabIndexflags.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setSelectTab(self, val='True', **kwargs):
        """
        The name, in short form, of the selected tab.  An empty string is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setSelectTabIndex(self, val='True', **kwargs):
        """
        Identical to the -st/selectTabflag except this flag takes a 1-based index to identify the selected tab.  A value of 0 is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setShowNewTab(self, val='True', **kwargs):
        """
        Set to true if you want to have a 'New Tab' button shown at the end of the tab bar.  Note: use the -ntc/newTabCommandflag to set the command executed when this button is clicked.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setTabLabel(self, val='True', **kwargs):
        """
        Set a tab label.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the label for the tab associated with that child. If this flag is queried then the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setTabLabelIndex(self, val='True', **kwargs):
        """
        Identical to the -tl/tabLabelflag except this flag takes a 1-based index to identify the tab you want to set the label for. If this flag is queried the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setTabPosition(self, val='True', **kwargs):
        """
        Changes the tab position. The possible values are: north, eastand west.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setTabTooltip(self, val='True', **kwargs):
        """
        Set a tab tooltip.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the tooltip for the tab associated with that child. If this flag is queried then the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setTabTooltipIndex(self, val='True', **kwargs):
        """
        Identical to the -tt/tabTooltipflag except this flag takes a 1-based index to identify the tab you want to set the tooltip for. If this flag is queried the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setTabsVisible(self, val='True', **kwargs):
        """
        Visibility of the tab labels.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    def verticalScrollBarThickness(self, val='True', **kwargs):
        """
        Thickness of the vertical scroll bar.  Specify an integer value greater than or equal to zero. This flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates/edits/queries a shelf tab group which is essentially a
        normal tabLayout with some drop behaviour in the tab bar.  A garbage can icon
        can appear in the top right corner to dispose of buttons dragged to it from
        shelves.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - borderStyle : bs               (unicode)       [create,query,edit]
            Specify the style of the border for tab layout. Valid values are: none, top,
            notopand full. By default, it will use fullto draw a simple frame around the
            body area of the tab layout. none- Do not draw borders around the body area of
            the tab layouttop- Only draw a simple line right below the tabsnotop- Draw a
            simple frame on the left/right/bottom (no top) of the tab layoutfull- Draw a
            simple frame around the body area of the tab layout
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when a tab is selected interactively. This command is only
            invoked when the selected tab changes. Re-selecting the current tab will not
            invoke this command.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - childResizable : cr            (bool)          [create,query]
            Set to true if you want the child of the control layout to be as wide as the
            scroll area.  You may also indicate a minimum width for the child using the
            -mcw/minChildWidthflag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,edit]
            Command executed when a tab is double clicked on.  Note that the first click
            will select the tab and the second click will execute the double click command.
            Double clicking the current tab will re-invoke the double click command.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontalScrollBarThickness : hst (int)           [create,edit]
            Thickness of the horizontal scroll bar.  Specify an integer value greater than
            or equal to zero. This flag has no effect on Windows systems.
        
        - image : i                      (unicode)       [create,query,edit]
            Image appearing in top right corner of tab layout.
        
        - imageVisible : iv              (bool)          [create,query,edit]
            Visibility of tab image.
        
        - innerMarginHeight : imh        (int)           [create,query]
            Margin height for all tab children.
        
        - innerMarginWidth : imw         (int)           [create,query]
            Margin width for all tab children.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - minChildWidth : mcw            (int)           [create,query]
            Specify a positive non-zero integer value indicating the minimum width the tab
            layout's children.  This flag only has meaning when the -cr/childResizableflag
            is set to true.
        
        - moveTab : mt                   (int, int)      [create,edit]
            Move the tab from the current index to a new index.
        
        - newTabCommand : ntc            (script)        [create,edit]
            Command executed when the 'New Tab' button (on the tab bar) is clicked.  Note:
            in order to show the new tab button use the -snt/showNewTabflag.  Using this
            command will override any internal Maya logic for adding a new tab (only this
            command will be executed).
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preSelectCommand : psc         (script)        [create,edit]
            Command executed when a tab is selected but before it's contents become visible.
            Re-selecting the current tab will not invoke this command.  Note that this
            command is not executed by using either of the -st/selectTabor
            -sti/selectTabIndexflags.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - scrollable : scr               (bool)          [create,query]
            Puts all children of this layout within a scroll area.
        
        - scrollableTabs : stb           (bool)          [create,query,edit]
            If true, the active tab in the layout can be scrolled through with the mouse
            wheel. Default is true.
        
        - selectCommand : sc             (script)        [create,query,edit]
            Command executed when a tab is selected interactively  This command will be
            invoked whenever a tab is selected, ie. re-selecting the current tab will invoke
            this command.  Note that this command is not executed by using either of the
            -st/selectTabor -sti/selectTabIndexflags.
        
        - selectTab : st                 (unicode)       [create,query,edit]
            The name, in short form, of the selected tab.  An empty string is returned on
            query if there are no child tabs.
        
        - selectTabIndex : sti           (int)           [create,query,edit]
            Identical to the -st/selectTabflag except this flag takes a 1-based index to
            identify the selected tab.  A value of 0 is returned on query if there are no
            child tabs.
        
        - showNewTab : snt               (bool)          [create,query,edit]
            Set to true if you want to have a 'New Tab' button shown at the end of the tab
            bar.  Note: use the -ntc/newTabCommandflag to set the command executed when this
            button is clicked.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - tabLabel : tl                  (unicode, unicode) [create,query,edit]
            Set a tab label.  The first argument is the name of a control that must be a
            child of the tab layout.  The second argument is the label for the tab
            associated with that child. If this flag is queried then the tab labels for all
            the children are returned.
        
        - tabLabelIndex : tli            (int, unicode)  [create,query,edit]
            Identical to the -tl/tabLabelflag except this flag takes a 1-based index to
            identify the tab you want to set the label for. If this flag is queried the tab
            labels for all the children are returned.
        
        - tabPosition : tp               (unicode)       [create,query,edit]
            Changes the tab position. The possible values are: north, eastand west.
        
        - tabTooltip : tt                (unicode, unicode) [create,query,edit]
            Set a tab tooltip.  The first argument is the name of a control that must be a
            child of the tab layout.  The second argument is the tooltip for the tab
            associated with that child. If this flag is queried then the tab tooltips for
            all the children are returned.
        
        - tabTooltipIndex : tti          (int, unicode)  [create,query,edit]
            Identical to the -tt/tabTooltipflag except this flag takes a 1-based index to
            identify the tab you want to set the tooltip for. If this flag is queried the
            tab tooltips for all the children are returned.
        
        - tabsClosable : tc              (bool)          [create,query]
            Set to true if you want to have a close button icon on all created tabs.
        
        - tabsVisible : tv               (bool)          [create,query,edit]
            Visibility of the tab labels.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - verticalScrollBarThickness : vst (int)           [create,edit]
            Thickness of the vertical scroll bar.  Specify an integer value greater than or
            equal to zero. This flag has no effect on Windows systems.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.shelfTabLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'shelfTabLayout'
    
    
    __melui__ = 'shelfTabLayout'


class FloatSliderButtonGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def buttonCommand(self, val='True', **kwargs):
        """
        Command string to be executed when the button is pressed.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command string executed when the value of the slider changes.  It will be executed only once after a drag of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command string executed repeatedly during a drag of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getButtonLabel(self, **kwargs):
        """
        The button text.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be an extra label appearing after the slider.  Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getFieldMaxValue(self, **kwargs):
        """
        Maximum value that may be entered in the field.  This value may be set to any value greater than the -max/maxValueflag.  By default, it is equal to the -max/maxValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getFieldMinValue(self, **kwargs):
        """
        Minimum value that may be entered in the field.  This value may be set to any value less than the -min/minValueflag.  By default, it is equal to the -min/minValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getFieldStep(self, **kwargs):
        """
        Increment for the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getImage(self, **kwargs):
        """
        Image displayed on the symbol button.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        If present on creation the group will have static text.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Maximum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Minimum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getSliderStep(self, **kwargs):
        """
        The slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getStep(self, **kwargs):
        """
        Increment for both the slider and field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getSymbolButtonDisplay(self, **kwargs):
        """
        Visibility of the symbol button.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the group.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def precision(self, val='True', **kwargs):
        """
        Number of digits to the right of the decimal.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setButtonLabel(self, val='True', **kwargs):
        """
        The button text.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be an extra label appearing after the slider.  Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setFieldMaxValue(self, val='True', **kwargs):
        """
        Maximum value that may be entered in the field.  This value may be set to any value greater than the -max/maxValueflag.  By default, it is equal to the -max/maxValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setFieldMinValue(self, val='True', **kwargs):
        """
        Minimum value that may be entered in the field.  This value may be set to any value less than the -min/minValueflag.  By default, it is equal to the -min/minValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setFieldStep(self, val='True', **kwargs):
        """
        Increment for the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Image displayed on the symbol button.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        If present on creation the group will have static text.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Maximum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Minimum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setSliderStep(self, val='True', **kwargs):
        """
        The slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Increment for both the slider and field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setSymbolButtonDisplay(self, val='True', **kwargs):
        """
        Visibility of the symbol button.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the group.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    def symbolButtonCommand(self, val='True', **kwargs):
        """
        Command string executed when the symbol button is pressed.                  
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a float slider component with optional button and symbol
        buttons. TelfFloatSliderGrpCmd.cpp
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - buttonCommand : bc             (script)        [create,edit]
            Command string to be executed when the button is pressed.
        
        - buttonLabel : bl               (unicode)       [create,query,edit]
            The button text.
        
        - changeCommand : cc             (script)        [create,edit]
            Command string executed when the value of the slider changes.  It will be
            executed only once after a drag of the slider.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command string executed repeatedly during a drag of the slider.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            If present on creation this specifies that there will be an extra label
            appearing after the slider.  Sets the string to be the text for the extra label.
        
        - field : f                      (bool)          [create]
            Indicates whether the group will have an editable float field present that
            reflects the value of the slider.
        
        - fieldMaxValue : fmx            (float)         [create,query,edit]
            Maximum value that may be entered in the field.  This value may be set to any
            value greater than the -max/maxValueflag.  By default, it is equal to the
            -max/maxValueflag.
        
        - fieldMinValue : fmn            (float)         [create,query,edit]
            Minimum value that may be entered in the field.  This value may be set to any
            value less than the -min/minValueflag.  By default, it is equal to the
            -min/minValueflag.
        
        - fieldStep : fs                 (float)         [create,query,edit]
            Increment for the field.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - image : i                      (unicode)       [create,query,edit]
            Image displayed on the symbol button.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            If present on creation the group will have static text.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (float)         [create,query,edit]
            Maximum value for both the slider and the field.
        
        - minValue : min                 (float)         [create,query,edit]
            Minimum value for both the slider and the field.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [create,edit]
            Number of digits to the right of the decimal.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - sliderStep : ss                (float)         [create,query,edit]
            The slider step value represents the amount the value will increase or decrease
            when you click either side of the slider.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            Increment for both the slider and field.
        
        - symbolButtonCommand : sbc      (script)        [create,edit]
            Command string executed when the symbol button is pressed.
        
        - symbolButtonDisplay : sbd      (bool)          [create,query,edit]
            Visibility of the symbol button.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (float)         [create,query,edit]
            Value of the group.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.floatSliderButtonGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'floatSliderButtonGrp'
    
    
    __melui__ = 'floatSliderButtonGrp'


class MenuBarLayout(Layout):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getMenuArray(self, **kwargs):
        """
        Return a string array containing the names of the menus in the layout's menu bar.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getMenuBarVisible(self, **kwargs):
        """
        Visibility of the menu bar.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getNumberOfMenus(self, **kwargs):
        """
        Return the number of menus attached to the layout's menu bar.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def menuIndex(self, val='True', **kwargs):
        """
        Sets the index of a specified menu.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setMenuBarVisible(self, val='True', **kwargs):
        """
        Visibility of the menu bar.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        Create a layout containing a menu bar.  The menu bar will appear and behave
        similar to any menu bar created with the 'window -menuBar true' command. Menus
        may be created with a menuBarLayout as their parent.  Child controls are simply
        positioned to fill the menuBarLayout area beneath the menu bar consequently,
        some other layout should be used as the immediate child.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - menuArray : ma                 (bool)          [query]
            Return a string array containing the names of the menus in the layout's menu
            bar.
        
        - menuBarVisible : mbv           (bool)          [create,query,edit]
            Visibility of the menu bar.
        
        - menuIndex : mi                 (unicode, int)  [edit]
            Sets the index of a specified menu.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfMenus : nm             (bool)          [query]
            Return the number of menus attached to the layout's menu bar.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.menuBarLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'menuBarLayout'
    
    
    __melui__ = 'menuBarLayout'


class ColorSliderButtonGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def buttonCommand(self, val='True', **kwargs):
        """
        Command string executed when the button is pressed.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command string executed when slider value changes.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command string executed when slider value marker is dragged.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getButtonLabel(self, **kwargs):
        """
        The button text.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getForceDragRefresh(self, **kwargs):
        """
        If used then force refresh on drag                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getHsvValue(self, **kwargs):
        """
        Color in hue, saturation, and value format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getImage(self, **kwargs):
        """
        Image displayed on the symbol button.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getRgbValue(self, **kwargs):
        """
        Color in red, green, and blue format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getSymbolButtonDisplay(self, **kwargs):
        """
        Visibility of the symbol button.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setButtonLabel(self, val='True', **kwargs):
        """
        The button text.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setForceDragRefresh(self, val='True', **kwargs):
        """
        If used then force refresh on drag                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setHsvValue(self, val='True', **kwargs):
        """
        Color in hue, saturation, and value format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Image displayed on the symbol button.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setRgbValue(self, val='True', **kwargs):
        """
        Color in red, green, and blue format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setSymbolButtonDisplay(self, val='True', **kwargs):
        """
        Visibility of the symbol button.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    def symbolButtonCommand(self, val='True', **kwargs):
        """
        Command string executed when the symbol button is pressed.                  
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command object creates a new color slider group with a button and a symbol
        button. This control is primarily used in the rendering UI. In this context, the
        button brings up a dialog that allows the user to assign a texture map to this
        parameter. Once a texture map is available, a symbol button shows up. When this
        symbol button is pressed, the user is taken to another dialog to edit the
        texture map.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - buttonCommand : bc             (script)        [create,edit]
            Command string executed when the button is pressed.
        
        - buttonLabel : bl               (unicode)       [create,query,edit]
            The button text.
        
        - changeCommand : cc             (script)        [create,edit]
            Command string executed when slider value changes.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command string executed when slider value marker is dragged.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - forceDragRefresh : fdr         (bool)          [create,query,edit]
            If used then force refresh on drag
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - hsvValue : hsv                 (float, float, float) [create,query,edit]
            Color in hue, saturation, and value format.
        
        - image : i                      (unicode)       [create,query,edit]
            Image displayed on the symbol button.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Label text for the group.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rgbValue : rgb                 (float, float, float) [create,query,edit]
            Color in red, green, and blue format.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - symbolButtonCommand : sbc      (script)        [create,edit]
            Command string executed when the symbol button is pressed.
        
        - symbolButtonDisplay : sbd      (bool)          [create,query,edit]
            Visibility of the symbol button.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.colorSliderButtonGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'colorSliderButtonGrp'
    
    
    __melui__ = 'colorSliderButtonGrp'


class TabLayout(Layout):
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is selected interactively. This command is only invoked when the selected tab changes. Re-selecting the current tab will not invoke this command.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def doubleClickCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is double clicked on.  Note that the first click will select the tab and the second click will execute the double click command.  Double clicking the current tab will re-invoke the double click command.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getBorderStyle(self, **kwargs):
        """
        Specify the style of the border for tab layout. Valid values are: none, top, notopand full. By default, it will use fullto draw a simple frame around the body area of the tab layout. none- Do not draw borders around the body area of the tab layouttop- Only draw a simple line right below the tabsnotop- Draw a simple frame on the left/right/bottom (no top) of the tab layoutfull- Draw a simple frame around the body area of the tab layout
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getChildResizable(self, **kwargs):
        """
        Set to true if you want the child of the control layout to be as wide as the scroll area.  You may also indicate a minimum width for the child using the -mcw/minChildWidthflag.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getImage(self, **kwargs):
        """
        Image appearing in top right corner of tab layout.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getImageVisible(self, **kwargs):
        """
        Visibility of tab image.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getInnerMarginHeight(self, **kwargs):
        """
        Margin height for all tab children.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getInnerMarginWidth(self, **kwargs):
        """
        Margin width for all tab children.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getMinChildWidth(self, **kwargs):
        """
        Specify a positive non-zero integer value indicating the minimum width the tab layout's children.  This flag only has meaning when the -cr/childResizableflag is set to true.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getScrollable(self, **kwargs):
        """
        Puts all children of this layout within a scroll area.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getScrollableTabs(self, **kwargs):
        """
        If true, the active tab in the layout can be scrolled through with the mouse wheel. Default is true.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getSelectCommand(self, **kwargs):
        """
        Command executed when a tab is selected interactively  This command will be invoked whenever a tab is selected, ie. re-selecting the current tab will invoke this command.  Note that this command is not executed by using either of the -st/selectTabor -sti/selectTabIndexflags.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getSelectTab(self, **kwargs):
        """
        The name, in short form, of the selected tab.  An empty string is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getSelectTabIndex(self, **kwargs):
        """
        Identical to the -st/selectTabflag except this flag takes a 1-based index to identify the selected tab.  A value of 0 is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getShowNewTab(self, **kwargs):
        """
        Set to true if you want to have a 'New Tab' button shown at the end of the tab bar.  Note: use the -ntc/newTabCommandflag to set the command executed when this button is clicked.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getTabLabel(self, **kwargs):
        """
        Set a tab label.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the label for the tab associated with that child. If this flag is queried then the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getTabLabelIndex(self, **kwargs):
        """
        Identical to the -tl/tabLabelflag except this flag takes a 1-based index to identify the tab you want to set the label for. If this flag is queried the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getTabPosition(self, **kwargs):
        """
        Changes the tab position. The possible values are: north, eastand west.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getTabTooltip(self, **kwargs):
        """
        Set a tab tooltip.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the tooltip for the tab associated with that child. If this flag is queried then the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getTabTooltipIndex(self, **kwargs):
        """
        Identical to the -tt/tabTooltipflag except this flag takes a 1-based index to identify the tab you want to set the tooltip for. If this flag is queried the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getTabsClosable(self, **kwargs):
        """
        Set to true if you want to have a close button icon on all created tabs.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getTabsVisible(self, **kwargs):
        """
        Visibility of the tab labels.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def horizontalScrollBarThickness(self, val='True', **kwargs):
        """
        Thickness of the horizontal scroll bar.  Specify an integer value greater than or equal to zero. This flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def moveTab(self, val='True', **kwargs):
        """
        Move the tab from the current index to a new index.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def newTabCommand(self, val='True', **kwargs):
        """
        Command executed when the 'New Tab' button (on the tab bar) is clicked.  Note: in order to show the new tab button use the -snt/showNewTabflag.  Using this command will override any internal Maya logic for adding a new tab (only this command will be executed).                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def preSelectCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is selected but before it's contents become visible.  Re-selecting the current tab will not invoke this command.  Note that this command is not executed by using either of the -st/selectTabor -sti/selectTabIndexflags.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setBorderStyle(self, val='True', **kwargs):
        """
        Specify the style of the border for tab layout. Valid values are: none, top, notopand full. By default, it will use fullto draw a simple frame around the body area of the tab layout. none- Do not draw borders around the body area of the tab layouttop- Only draw a simple line right below the tabsnotop- Draw a simple frame on the left/right/bottom (no top) of the tab layoutfull- Draw a simple frame around the body area of the tab layout
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setImage(self, val='True', **kwargs):
        """
        Image appearing in top right corner of tab layout.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setImageVisible(self, val='True', **kwargs):
        """
        Visibility of tab image.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setScrollableTabs(self, val='True', **kwargs):
        """
        If true, the active tab in the layout can be scrolled through with the mouse wheel. Default is true.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setSelectCommand(self, val='True', **kwargs):
        """
        Command executed when a tab is selected interactively  This command will be invoked whenever a tab is selected, ie. re-selecting the current tab will invoke this command.  Note that this command is not executed by using either of the -st/selectTabor -sti/selectTabIndexflags.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setSelectTab(self, val='True', **kwargs):
        """
        The name, in short form, of the selected tab.  An empty string is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setSelectTabIndex(self, val='True', **kwargs):
        """
        Identical to the -st/selectTabflag except this flag takes a 1-based index to identify the selected tab.  A value of 0 is returned on query if there are no child tabs.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setShowNewTab(self, val='True', **kwargs):
        """
        Set to true if you want to have a 'New Tab' button shown at the end of the tab bar.  Note: use the -ntc/newTabCommandflag to set the command executed when this button is clicked.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setTabLabel(self, val='True', **kwargs):
        """
        Set a tab label.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the label for the tab associated with that child. If this flag is queried then the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setTabLabelIndex(self, val='True', **kwargs):
        """
        Identical to the -tl/tabLabelflag except this flag takes a 1-based index to identify the tab you want to set the label for. If this flag is queried the tab labels for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setTabPosition(self, val='True', **kwargs):
        """
        Changes the tab position. The possible values are: north, eastand west.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setTabTooltip(self, val='True', **kwargs):
        """
        Set a tab tooltip.  The first argument is the name of a control that must be a child of the tab layout.  The second argument is the tooltip for the tab associated with that child. If this flag is queried then the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setTabTooltipIndex(self, val='True', **kwargs):
        """
        Identical to the -tt/tabTooltipflag except this flag takes a 1-based index to identify the tab you want to set the tooltip for. If this flag is queried the tab tooltips for all the children are returned.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setTabsVisible(self, val='True', **kwargs):
        """
        Visibility of the tab labels.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    def verticalScrollBarThickness(self, val='True', **kwargs):
        """
        Thickness of the vertical scroll bar.  Specify an integer value greater than or equal to zero. This flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a tab group. Tab groups are a specialized form of control
        layouts that contain only control layouts. Whenever a control layout is added to
        a tab group it will have a tab provided for it that allows selection of that
        group from amongst other tabbed control groups. Only one child of a tab layout
        is visible at a time.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - borderStyle : bs               (unicode)       [create,query,edit]
            Specify the style of the border for tab layout. Valid values are: none, top,
            notopand full. By default, it will use fullto draw a simple frame around the
            body area of the tab layout. none- Do not draw borders around the body area of
            the tab layouttop- Only draw a simple line right below the tabsnotop- Draw a
            simple frame on the left/right/bottom (no top) of the tab layoutfull- Draw a
            simple frame around the body area of the tab layout
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when a tab is selected interactively. This command is only
            invoked when the selected tab changes. Re-selecting the current tab will not
            invoke this command.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - childResizable : cr            (bool)          [create,query]
            Set to true if you want the child of the control layout to be as wide as the
            scroll area.  You may also indicate a minimum width for the child using the
            -mcw/minChildWidthflag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - doubleClickCommand : dcc       (script)        [create,edit]
            Command executed when a tab is double clicked on.  Note that the first click
            will select the tab and the second click will execute the double click command.
            Double clicking the current tab will re-invoke the double click command.
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontalScrollBarThickness : hst (int)           [create,edit]
            Thickness of the horizontal scroll bar.  Specify an integer value greater than
            or equal to zero. This flag has no effect on Windows systems.
        
        - image : i                      (unicode)       [create,query,edit]
            Image appearing in top right corner of tab layout.
        
        - imageVisible : iv              (bool)          [create,query,edit]
            Visibility of tab image.
        
        - innerMarginHeight : imh        (int)           [create,query]
            Margin height for all tab children.
        
        - innerMarginWidth : imw         (int)           [create,query]
            Margin width for all tab children.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - minChildWidth : mcw            (int)           [create,query]
            Specify a positive non-zero integer value indicating the minimum width the tab
            layout's children.  This flag only has meaning when the -cr/childResizableflag
            is set to true.
        
        - moveTab : mt                   (int, int)      [create,edit]
            Move the tab from the current index to a new index.
        
        - newTabCommand : ntc            (script)        [create,edit]
            Command executed when the 'New Tab' button (on the tab bar) is clicked.  Note:
            in order to show the new tab button use the -snt/showNewTabflag.  Using this
            command will override any internal Maya logic for adding a new tab (only this
            command will be executed).
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preSelectCommand : psc         (script)        [create,edit]
            Command executed when a tab is selected but before it's contents become visible.
            Re-selecting the current tab will not invoke this command.  Note that this
            command is not executed by using either of the -st/selectTabor
            -sti/selectTabIndexflags.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - scrollable : scr               (bool)          [create,query]
            Puts all children of this layout within a scroll area.
        
        - scrollableTabs : stb           (bool)          [create,query,edit]
            If true, the active tab in the layout can be scrolled through with the mouse
            wheel. Default is true.
        
        - selectCommand : sc             (script)        [create,query,edit]
            Command executed when a tab is selected interactively  This command will be
            invoked whenever a tab is selected, ie. re-selecting the current tab will invoke
            this command.  Note that this command is not executed by using either of the
            -st/selectTabor -sti/selectTabIndexflags.
        
        - selectTab : st                 (unicode)       [create,query,edit]
            The name, in short form, of the selected tab.  An empty string is returned on
            query if there are no child tabs.
        
        - selectTabIndex : sti           (int)           [create,query,edit]
            Identical to the -st/selectTabflag except this flag takes a 1-based index to
            identify the selected tab.  A value of 0 is returned on query if there are no
            child tabs.
        
        - showNewTab : snt               (bool)          [create,query,edit]
            Set to true if you want to have a 'New Tab' button shown at the end of the tab
            bar.  Note: use the -ntc/newTabCommandflag to set the command executed when this
            button is clicked.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - tabLabel : tl                  (unicode, unicode) [create,query,edit]
            Set a tab label.  The first argument is the name of a control that must be a
            child of the tab layout.  The second argument is the label for the tab
            associated with that child. If this flag is queried then the tab labels for all
            the children are returned.
        
        - tabLabelIndex : tli            (int, unicode)  [create,query,edit]
            Identical to the -tl/tabLabelflag except this flag takes a 1-based index to
            identify the tab you want to set the label for. If this flag is queried the tab
            labels for all the children are returned.
        
        - tabPosition : tp               (unicode)       [create,query,edit]
            Changes the tab position. The possible values are: north, eastand west.
        
        - tabTooltip : tt                (unicode, unicode) [create,query,edit]
            Set a tab tooltip.  The first argument is the name of a control that must be a
            child of the tab layout.  The second argument is the tooltip for the tab
            associated with that child. If this flag is queried then the tab tooltips for
            all the children are returned.
        
        - tabTooltipIndex : tti          (int, unicode)  [create,query,edit]
            Identical to the -tt/tabTooltipflag except this flag takes a 1-based index to
            identify the tab you want to set the tooltip for. If this flag is queried the
            tab tooltips for all the children are returned.
        
        - tabsClosable : tc              (bool)          [create,query]
            Set to true if you want to have a close button icon on all created tabs.
        
        - tabsVisible : tv               (bool)          [create,query,edit]
            Visibility of the tab labels.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - verticalScrollBarThickness : vst (int)           [create,edit]
            Thickness of the vertical scroll bar.  Specify an integer value greater than or
            equal to zero. This flag has no effect on Windows systems.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.tabLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'tabLayout'
    
    
    __melui__ = 'tabLayout'


class IntFieldGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command string executed when the value of any of the fields changes.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command string executed when dragging the invisible slider in any of the fields.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getEnable1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getEnable2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getEnable3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getEnable4(self, **kwargs):
        """
        Enable state for the respective field.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be an extra label in the group.  Sets the string to be label text to the right of fields.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be a label to the left of the fields.  Sets the string to be the label text.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getValue(self, **kwargs):
        """
        Values for all fields.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getValue1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getValue2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getValue3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getValue4(self, **kwargs):
        """
        Value for the respective field.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setEnable1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setEnable2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setEnable3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setEnable4(self, val='True', **kwargs):
        """
        Enable state for the respective field.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be an extra label in the group.  Sets the string to be label text to the right of fields.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be a label to the left of the fields.  Sets the string to be the label text.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Values for all fields.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setValue1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setValue2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setValue3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setValue4(self, val='True', **kwargs):
        """
        Value for the respective field.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of label text and editable integer
        fields. The label text is optional and one to four fields can be created.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command string executed when the value of any of the fields changes.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command string executed when dragging the invisible slider in any of the fields.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enable1 : en1                  (bool)          [create,query,edit]
        
        - enable2 : en2                  (bool)          [create,query,edit]
        
        - enable3 : en3                  (bool)          [create,query,edit]
        
        - enable4 : en4                  (bool)          [create,query,edit]
            Enable state for the respective field.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            If present on creation this specifies that there will be an extra label in the
            group.  Sets the string to be label text to the right of fields.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            If present on creation this specifies that there will be a label to the left of
            the fields.  Sets the string to be the label text.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfFields : nf            (int)           [create]
            Set the number of fields on creation.  One to four fields are available.  The
            default is one field.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (int, int, int, int) [create,query,edit]
            Values for all fields.
        
        - value1 : v1                    (int)           [create,query,edit]
        
        - value2 : v2                    (int)           [create,query,edit]
        
        - value3 : v3                    (int)           [create,query,edit]
        
        - value4 : v4                    (int)           [create,query,edit]
            Value for the respective field.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.intFieldGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'intFieldGrp'
    
    
    __melui__ = 'intFieldGrp'


class FrameLayout(Layout):
    def collapseCommand(self, val='True', **kwargs):
        """
        Command executed after the frame is collapsed.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def expandCommand(self, val='True', **kwargs):
        """
        Command executed after the frame is expanded.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getBackgroundShade(self, **kwargs):
        """
        Controls whether the background of the frame layout draws with a shaded effect. It is turned off by default.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getBorderStyle(self, **kwargs):
        """
        This flag is obsolete. The border style is no longer supported. Using this flag will return a warning.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getBorderVisible(self, **kwargs):
        """
        Visibility of the border.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getCollapsable(self, **kwargs):
        """
        Collapsibility of the frame layout.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getCollapse(self, **kwargs):
        """
        Collapse state of the frame layout.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getFont(self, **kwargs):
        """
        The font for the frame label.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label string for the frame layout.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getLabelAlign(self, **kwargs):
        """
        How to align the label. Default is top.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getLabelIndent(self, **kwargs):
        """
        Indentation for the frame label.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getLabelVisible(self, **kwargs):
        """
        Visibility of the frame label.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getLabelWidth(self, **kwargs):
        """
        Width of the label.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getMarginHeight(self, **kwargs):
        """
        Vertical distance between the frame and its children.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getMarginWidth(self, **kwargs):
        """
        Horizontal distance between the frame and its children.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def preCollapseCommand(self, val='True', **kwargs):
        """
        Command executed just before the frame is collapsed.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def preExpandCommand(self, val='True', **kwargs):
        """
        Command executed just before the frame is expanded.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setBackgroundShade(self, val='True', **kwargs):
        """
        Controls whether the background of the frame layout draws with a shaded effect. It is turned off by default.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setBorderStyle(self, val='True', **kwargs):
        """
        This flag is obsolete. The border style is no longer supported. Using this flag will return a warning.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setBorderVisible(self, val='True', **kwargs):
        """
        Visibility of the border.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setCollapsable(self, val='True', **kwargs):
        """
        Collapsibility of the frame layout.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setCollapse(self, val='True', **kwargs):
        """
        Collapse state of the frame layout.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setFont(self, val='True', **kwargs):
        """
        The font for the frame label.  Valid values are boldLabelFont, smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont, obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label string for the frame layout.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setLabelAlign(self, val='True', **kwargs):
        """
        How to align the label. Default is top.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setLabelIndent(self, val='True', **kwargs):
        """
        Indentation for the frame label.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setLabelVisible(self, val='True', **kwargs):
        """
        Visibility of the frame label.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setLabelWidth(self, val='True', **kwargs):
        """
        Width of the label.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setMarginHeight(self, val='True', **kwargs):
        """
        Vertical distance between the frame and its children.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setMarginWidth(self, val='True', **kwargs):
        """
        Horizontal distance between the frame and its children.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates frame layout control. A frame layout may draw a border
        around its child controls as well as a display a title. Frame layouts may also
        be collapsable. Collapsing a frame layout will make the child of the frame
        layout invisible and shrink the frame layout size. The frame layout may then be
        expanded to make its child visible. Note that the frame layout may have only one
        child control.  If you wish to have more than one child inside a frame layout
        then you must use some other control layout as the immediate child of the frame
        layout.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - backgroundShade : bgs          (bool)          [create,query,edit]
            Controls whether the background of the frame layout draws with a shaded effect.
            It is turned off by default.
        
        - borderStyle : bs               (unicode)       [create,query,edit]
            This flag is obsolete. The border style is no longer supported. Using this flag
            will return a warning.
        
        - borderVisible : bv             (bool)          [create,query,edit]
            Visibility of the border.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - collapsable : cll              (bool)          [create,query,edit]
            Collapsibility of the frame layout.
        
        - collapse : cl                  (bool)          [create,query,edit]
            Collapse state of the frame layout.
        
        - collapseCommand : cc           (script)        [create,edit]
            Command executed after the frame is collapsed.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - expandCommand : ec             (script)        [create,edit]
            Command executed after the frame is expanded.
        
        - font : fn                      (unicode)       [create,query,edit]
            The font for the frame label.  Valid values are boldLabelFont,
            smallBoldLabelFont, tinyBoldLabelFont, plainLabelFont, smallPlainLabelFont,
            obliqueLabelFont, smallObliqueLabelFont, fixedWidthFontand smallFixedWidthFont.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Label string for the frame layout.
        
        - labelAlign : la                (unicode)       [create,query,edit]
            How to align the label. Default is top.
        
        - labelIndent : li               (int)           [create,query,edit]
            Indentation for the frame label.
        
        - labelVisible : lv              (bool)          [create,query,edit]
            Visibility of the frame label.
        
        - labelWidth : lw                (int)           [create,query,edit]
            Width of the label.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - marginHeight : mh              (int)           [create,query,edit]
            Vertical distance between the frame and its children.
        
        - marginWidth : mw               (int)           [create,query,edit]
            Horizontal distance between the frame and its children.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preCollapseCommand : pcc       (script)        [create,edit]
            Command executed just before the frame is collapsed.
        
        - preExpandCommand : pec         (script)        [create,edit]
            Command executed just before the frame is expanded.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.frameLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'frameLayout'
    
    
    __melui__ = 'frameLayout'


class GridLayout(Layout):
    def cellWidthHeight(self, val='True', **kwargs):
        """
        Two positive non-zero integer values for indicating the width and height, respectively, of the cells in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getAllowEmptyCells(self, **kwargs):
        """
        Specify true if you want free positioning of the children in the layout and potentially leaving empty cells between children. Set to false if you want the children to always be packed together. The default is true.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getAutoGrow(self, **kwargs):
        """
        Specify true if you want the grid layout size to grow as children are added.  For example, if the grid layout has 2 columns and 2 rows then adding a fifth child will cause the grid to expand to 3 rows if this flag is true, otherwise the grid will remain the same size and the new child will be hidden from view until you expand the size of the grid using the appropriate flags.  The default is true.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getCellHeight(self, **kwargs):
        """
        A positive non-zero integer value indicating the height of cells in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getCellWidth(self, **kwargs):
        """
        A positive non-zero integer value indicating the width of cells in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getColumnsResizable(self, **kwargs):
        """
        Specify true if you want the number of columns to adjust according to the width of the layout.  Set to false if you want the number of columns to remain fixed when the width of the layout is changed.  The default is false.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getGridOrder(self, **kwargs):
        """
        As opposed to the childArray flag, the gridOrder flag returns the children of the grid Layout in the order they are diplayed in the window.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getNumberOfColumns(self, **kwargs):
        """
        A positive non-zero integer value indicating the number of columns in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getNumberOfRows(self, **kwargs):
        """
        A positive non-zero integer value indicating the number of rows in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def numberOfRowsColumns(self, val='True', **kwargs):
        """
        Two positive non-zero integer values for the number of rows and columns, respectively, in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def position(self, val='True', **kwargs):
        """
        Specify the name of a child control in the grid layout along with a 1-based integer value indicating the desired position of the child.  Positions increase from left to right within a row and then wrap around to the next row increasing from top to bottom.  For example, a grid layout with 3 columns and 2 rows has 6 visible positions where 1, 2 and 3 occupy the first row and 4, 5 and 6 occupy the second.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setCellHeight(self, val='True', **kwargs):
        """
        A positive non-zero integer value indicating the height of cells in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setCellWidth(self, val='True', **kwargs):
        """
        A positive non-zero integer value indicating the width of cells in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setNumberOfColumns(self, val='True', **kwargs):
        """
        A positive non-zero integer value indicating the number of columns in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setNumberOfRows(self, val='True', **kwargs):
        """
        A positive non-zero integer value indicating the number of rows in the grid layout.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This layout arranges children in a grid fashion where every cell in the grid is
        the same size.  You may specify the number of rows and columns as well as the
        width and height of the grid cells.
        
        Flags:
        - allowEmptyCells : aec          (bool)          [create,query]
            Specify true if you want free positioning of the children in the layout and
            potentially leaving empty cells between children. Set to false if you want the
            children to always be packed together. The default is true.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - autoGrow : ag                  (bool)          [create,query]
            Specify true if you want the grid layout size to grow as children are added.
            For example, if the grid layout has 2 columns and 2 rows then adding a fifth
            child will cause the grid to expand to 3 rows if this flag is true, otherwise
            the grid will remain the same size and the new child will be hidden from view
            until you expand the size of the grid using the appropriate flags.  The default
            is true.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - cellHeight : ch                (int)           [create,query,edit]
            A positive non-zero integer value indicating the height of cells in the grid
            layout.
        
        - cellWidth : cw                 (int)           [create,query,edit]
            A positive non-zero integer value indicating the width of cells in the grid
            layout.
        
        - cellWidthHeight : cwh          (int, int)      [create,edit]
            Two positive non-zero integer values for indicating the width and height,
            respectively, of the cells in the grid layout.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - columnsResizable : cr          (bool)          [create,query]
            Specify true if you want the number of columns to adjust according to the width
            of the layout.  Set to false if you want the number of columns to remain fixed
            when the width of the layout is changed.  The default is false.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - gridOrder : go                 (bool)          [query]
            As opposed to the childArray flag, the gridOrder flag returns the children of
            the grid Layout in the order they are diplayed in the window.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfColumns : nc           (int)           [create,query,edit]
            A positive non-zero integer value indicating the number of columns in the grid
            layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - numberOfRows : nr              (int)           [create,query,edit]
            A positive non-zero integer value indicating the number of rows in the grid
            layout.
        
        - numberOfRowsColumns : nrc      (int, int)      [create,edit]
            Two positive non-zero integer values for the number of rows and columns,
            respectively, in the grid layout.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - position : pos                 (unicode, int)  [create,edit]
            Specify the name of a child control in the grid layout along with a 1-based
            integer value indicating the desired position of the child.  Positions increase
            from left to right within a row and then wrap around to the next row increasing
            from top to bottom.  For example, a grid layout with 3 columns and 2 rows has 6
            visible positions where 1, 2 and 3 occupy the first row and 4, 5 and 6 occupy
            the second.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.gridLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'gridLayout'
    
    
    __melui__ = 'gridLayout'


class FloatFieldGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command string executed when the value of any of the fields changes.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command string executed when dragging the invisible slider in any of the fields.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getEnable1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getEnable2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getEnable3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getEnable4(self, **kwargs):
        """
        Enable state for the respective field.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be an extra label in the group.  Sets the string to be label text to the right of fields.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be a label to the left of the fields.  Sets the string to be the label text.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getStep(self, **kwargs):
        """
        Set the delta of invisioSlider delta , the invisioSlider step is delta/10.0 in LMB , delta in MMB,delta\*10.0 in RMB. Default is 10.0                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getValue(self, **kwargs):
        """
        Values for all fields.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getValue1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getValue2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getValue3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getValue4(self, **kwargs):
        """
        Value for the respective field.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def precision(self, val='True', **kwargs):
        """
        Set the number of digits to the right of the decimal.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setEnable1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setEnable2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setEnable3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setEnable4(self, val='True', **kwargs):
        """
        Enable state for the respective field.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be an extra label in the group.  Sets the string to be label text to the right of fields.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be a label to the left of the fields.  Sets the string to be the label text.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Set the delta of invisioSlider delta , the invisioSlider step is delta/10.0 in LMB , delta in MMB,delta\*10.0 in RMB. Default is 10.0                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Values for all fields.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setValue1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setValue2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setValue3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setValue4(self, val='True', **kwargs):
        """
        Value for the respective field.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def showTrailingZeros(self, val='True', **kwargs):
        """
        Show trailing zeros or not                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of label text and editable float
        fields.  The label text is optional and one to four float fields can be created.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command string executed when the value of any of the fields changes.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command string executed when dragging the invisible slider in any of the fields.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enable1 : en1                  (bool)          [create,query,edit]
        
        - enable2 : en2                  (bool)          [create,query,edit]
        
        - enable3 : en3                  (bool)          [create,query,edit]
        
        - enable4 : en4                  (bool)          [create,query,edit]
            Enable state for the respective field.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            If present on creation this specifies that there will be an extra label in the
            group.  Sets the string to be label text to the right of fields.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            If present on creation this specifies that there will be a label to the left of
            the fields.  Sets the string to be the label text.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfFields : nf            (int)           [create]
            Set the number of fields on creation. One to four fields are available.  The
            default is one field.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [create,edit]
            Set the number of digits to the right of the decimal.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - showTrailingZeros : tze        (bool)          [create,edit]
            Show trailing zeros or not
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            Set the delta of invisioSlider delta , the invisioSlider step is delta/10.0 in
            LMB , delta in MMB,delta\*10.0 in RMB. Default is 10.0
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (float, float, float, float) [create,query,edit]
            Values for all fields.
        
        - value1 : v1                    (float)         [create,query,edit]
        
        - value2 : v2                    (float)         [create,query,edit]
        
        - value3 : v3                    (float)         [create,query,edit]
        
        - value4 : v4                    (float)         [create,query,edit]
            Value for the respective field.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.floatFieldGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'floatFieldGrp'
    
    
    __melui__ = 'floatFieldGrp'


class ShelfLayout(Layout):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getAlignment(self, **kwargs):
        """
        Sets the alignment of the buttons in the layout. When horizontalis true, valid options are leftand right. When horizontalis false, valid options are topand bottom.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getCellHeight(self, **kwargs):
        """
        Set or query the height of the items in the shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getCellWidth(self, **kwargs):
        """
        Set or query the width of the items in the shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getCellWidthHeight(self, **kwargs):
        """
        Set the width and height of the items in the shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getHorizontal(self, **kwargs):
        """
        Orientation of the layout. This flag is true by default, which corresponds to a horizontally laid out shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getLtVersion(self, **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getSpacing(self, **kwargs):
        """
        Sets the space between children.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getStyle(self, **kwargs):
        """
        Set or query the current style of the items in the shelf.  Valid styles are iconOnly, textOnly, iconAndTextHorizontaland iconAndTextVertical.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getVersion(self, **kwargs):
        """
        Specify the version that this feature was introduced. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def position(self, val='True', **kwargs):
        """
        Specify the name of a child control in the grid layout along with a 1-based integer value indicating the desired position of the child. Positions increase from left to right within a row and then wrap around to the next row increasing from top to bottom. For example, a grid layout with 3 columns and 2 rows has 6 visible positions where 1, 2 and 3 occupy the first row and 4, 5 and 6 occupy the second.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setAlignment(self, val='True', **kwargs):
        """
        Sets the alignment of the buttons in the layout. When horizontalis true, valid options are leftand right. When horizontalis false, valid options are topand bottom.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setCellHeight(self, val='True', **kwargs):
        """
        Set or query the height of the items in the shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setCellWidth(self, val='True', **kwargs):
        """
        Set or query the width of the items in the shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setCellWidthHeight(self, val='True', **kwargs):
        """
        Set the width and height of the items in the shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setHorizontal(self, val='True', **kwargs):
        """
        Orientation of the layout. This flag is true by default, which corresponds to a horizontally laid out shelf.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setLtVersion(self, val='True', **kwargs):
        """
        This flag is used to specify the Maya LT version that this control feature was introduced, if the version flag is not specified, or if the version flag is specified but its argument is different. This value is only used by Maya LT, and otherwise ignored. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setSpacing(self, val='True', **kwargs):
        """
        Sets the space between children.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setStyle(self, val='True', **kwargs):
        """
        Set or query the current style of the items in the shelf.  Valid styles are iconOnly, textOnly, iconAndTextHorizontaland iconAndTextVertical.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setVersion(self, val='True', **kwargs):
        """
        Specify the version that this feature was introduced. The argument should be given as a string of the version number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g. 2014.5 should be given as 2014).                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a new empty shelf layout. The shelf layout can accept drops
        of commands scripts. Use the addNewShelfTabMEL command to add a shelf to the top
        level shelves.
        
        Flags:
        - alignment : aln                (unicode)       [create,query,edit]
            Sets the alignment of the buttons in the layout. When horizontalis true, valid
            options are leftand right. When horizontalis false, valid options are topand
            bottom.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - cellHeight : ch                (int)           [create,query,edit]
            Set or query the height of the items in the shelf.
        
        - cellWidth : cw                 (int)           [create,query,edit]
            Set or query the width of the items in the shelf.
        
        - cellWidthHeight : cwh          (int, int)      [create,query,edit]
            Set the width and height of the items in the shelf.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontal : hr                (bool)          [create,query,edit]
            Orientation of the layout. This flag is true by default, which corresponds to a
            horizontally laid out shelf.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - ltVersion : lt                 (unicode)       [create,query,edit]
            This flag is used to specify the Maya LT version that this control feature was
            introduced, if the version flag is not specified, or if the version flag is
            specified but its argument is different. This value is only used by Maya LT, and
            otherwise ignored. The argument should be given as a string of the version
            number (e.g. 2014, 2015). Currently only accepts major version numbers (e.g.
            2014.5 should be given as 2014).
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - position : pos                 (unicode, int)  [create,edit]
            Specify the name of a child control in the grid layout along with a 1-based
            integer value indicating the desired position of the child. Positions increase
            from left to right within a row and then wrap around to the next row increasing
            from top to bottom. For example, a grid layout with 3 columns and 2 rows has 6
            visible positions where 1, 2 and 3 occupy the first row and 4, 5 and 6 occupy
            the second.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - spacing : spa                  (int)           [create,query,edit]
            Sets the space between children.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - style : st                     (unicode)       [create,query,edit]
            Set or query the current style of the items in the shelf.  Valid styles are
            iconOnly, textOnly, iconAndTextHorizontaland iconAndTextVertical.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - version : ver                  (unicode)       [create,query,edit]
            Specify the version that this feature was introduced. The argument should be
            given as a string of the version number (e.g. 2014, 2015). Currently only
            accepts major version numbers (e.g. 2014.5 should be given as 2014).
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.shelfLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'shelfLayout'
    
    
    __melui__ = 'shelfLayout'


class OptionMenu(PopupMenu):
    def addItems(self, items, title='None'):
        """
        Add the specified item list to the OptionMenu, with an optional 'title' item
        """
        pass
    def addMenuItems(self, items, title='None'):
        """
        Add the specified item list to the OptionMenu, with an optional 'title' item
        """
        pass
    def beforeShowPopup(self, val='True', **kwargs):
        """
        Callback that is called just before we show the drop down menu.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Adds a callback that is called when a new item is selected. The MEL script will have the newly selected item's value substituted for #1. For Python, the callback should be a callable object which accepts one argument, which is the newly selected item's value.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def clear(self):
        """
        Clear all menu items from this OptionMenu
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getAlwaysCallChangeCommand(self, **kwargs):
        """
        Toggle whether to always call the change command, regardless of the change.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getItemListLong(self, **kwargs):
        """
        The long names of the menu items.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getItemListShort(self, **kwargs):
        """
        The short names of the menu items.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getLabel(self, **kwargs):
        """
        The optional label text to the left of the popup menu.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getMaxVisibleItems(self, **kwargs):
        """
        The maximum number of items that are visible in the popup menu. If the popup contains more items than this, a scrollbar is added automatically.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getNumberOfItems(self, **kwargs):
        """
        The number of menu items.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getSelect(self, **kwargs):
        """
        The current menu item.  The argument and return value is 1-based.  Note that the current menu item can only be set if it is enabled.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getValue(self, **kwargs):
        """
        The text of the current menu item.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        The optional label text to the left of the popup menu.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setMaxVisibleItems(self, val='True', **kwargs):
        """
        The maximum number of items that are visible in the popup menu. If the popup contains more items than this, a scrollbar is added automatically.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        The current menu item.  The argument and return value is 1-based.  Note that the current menu item can only be set if it is enabled.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        The text of the current menu item.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a popup menu control.  The command creates the control and
        provides its menu.  Subsequent calls to the menuItem command will place them in
        the popup.  Note that commands attached to menu items will not get called.
        Attach any commands via the -cc/changedCommand flag.
        
        Flags:
        - alwaysCallChangeCommand : acc  (bool)          [create,query]
            Toggle whether to always call the change command, regardless of the change.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - beforeShowPopup : bsp          (script)        [create,edit]
            Callback that is called just before we show the drop down menu.
        
        - changeCommand : cc             (script)        [create,edit]
            Adds a callback that is called when a new item is selected. The MEL script will
            have the newly selected item's value substituted for #1. For Python, the
            callback should be a callable object which accepts one argument, which is the
            newly selected item's value.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - deleteAllItems : dai           (bool)          []
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - itemListLong : ill             (bool)          [query]
            The long names of the menu items.
        
        - itemListShort : ils            (bool)          [query]
            The short names of the menu items.
        
        - label : l                      (unicode)       [create,query,edit]
            The optional label text to the left of the popup menu.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxVisibleItems : mvi          (int)           [create,query,edit]
            The maximum number of items that are visible in the popup menu. If the popup
            contains more items than this, a scrollbar is added automatically.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfItems : ni             (bool)          [query]
            The number of menu items.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - select : sl                    (int)           [create,query,edit]
            The current menu item.  The argument and return value is 1-based.  Note that the
            current menu item can only be set if it is enabled.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (unicode)       [create,query,edit]
            The text of the current menu item.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.optionMenu`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'optionMenu'
    
    
    __melui__ = 'optionMenu'


class AttrFieldSliderGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        The command string is executed when the value of the slider or floatField changes.  It will be executed only once after a drag of the slider.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def extraButtonCommand(self, val='True', **kwargs):
        """
        The command string is executed when the extra button is clicked.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        The name of a unique attribute of type double or int. This newly created field will be attached to the attribute, so that modifications to one will change the other.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getExtraButtonIcon(self, **kwargs):
        """
        The icon file name of the extra button.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getFieldMaxValue(self, **kwargs):
        """
        Set the maximum value for the field.  This flag allows you to specify a maximum bound for the field higher than that of the slider.   (See note above about max and min values.)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getFieldMinValue(self, **kwargs):
        """
        Set the minimum value for the field.  This flag allows you to specify a minimum bound for the field lower than that of the slider.  (See note above about max and min values.)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getFieldStep(self, **kwargs):
        """
        Sets the increment for the float field.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        By default, the label of this field will be the name of the attribute.  This flag can be used to override that name with whatever string you want.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Sets the maximum value for both the slider and the field. (See note above about min and max values)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Sets the minimum value for both the slider and the field. (by default max and min are set according to what is in the attribute, if anything.  If no max and min are specified, or if only one of the two are specified, then no slider is created.)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getSliderMaxValue(self, **kwargs):
        """
        Set the maximum value for the slider.  The slider max will be clipped to the field max.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getSliderMinValue(self, **kwargs):
        """
        Set the minimum value for the slider.  The slider min will be clipped to the field min.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getSliderStep(self, **kwargs):
        """
        On Linux the slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getStep(self, **kwargs):
        """
        Sets the increment for both the slider and float field.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getVertical(self, **kwargs):
        """
        Whether the orientation of the controls in this group are horizontal (default) or vertical.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def precision(self, val='True', **kwargs):
        """
        Sets the number of digits to the right of the decimal. (If attached to an int attribute, this is automatically set to 0 and cannot be overridden.)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        The name of a unique attribute of type double or int. This newly created field will be attached to the attribute, so that modifications to one will change the other.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setExtraButtonIcon(self, val='True', **kwargs):
        """
        The icon file name of the extra button.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setFieldMaxValue(self, val='True', **kwargs):
        """
        Set the maximum value for the field.  This flag allows you to specify a maximum bound for the field higher than that of the slider.   (See note above about max and min values.)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setFieldMinValue(self, val='True', **kwargs):
        """
        Set the minimum value for the field.  This flag allows you to specify a minimum bound for the field lower than that of the slider.  (See note above about max and min values.)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setFieldStep(self, val='True', **kwargs):
        """
        Sets the increment for the float field.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        By default, the label of this field will be the name of the attribute.  This flag can be used to override that name with whatever string you want.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Sets the maximum value for both the slider and the field. (See note above about min and max values)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Sets the minimum value for both the slider and the field. (by default max and min are set according to what is in the attribute, if anything.  If no max and min are specified, or if only one of the two are specified, then no slider is created.)                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setSliderMaxValue(self, val='True', **kwargs):
        """
        Set the maximum value for the slider.  The slider max will be clipped to the field max.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setSliderMinValue(self, val='True', **kwargs):
        """
        Set the minimum value for the slider.  The slider min will be clipped to the field min.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setSliderStep(self, val='True', **kwargs):
        """
        On Linux the slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Sets the increment for both the slider and float field.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of label text, float field and float
        slider (for values with a min or max specified) The group also supports the
        notion of a larger secondary range of possible field values. If an attribute is
        specified for this object, then it will use any min and max values defined in
        the attribute.  The user-specified values can reduce the min and max, but cannot
        expand them. The field created here is an expression field -- while normally
        operating as a float field, the user can type in any expression starting with
        the character =.  This will expand the field to occupy the space previously
        taken by the slider. The field also has an automatic menu brought up by the
        right mouse button. The contents of this menu change depending on the state of
        the attribute being watched by the field.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attribute : at                 (unicode)       [create,query,edit]
            The name of a unique attribute of type double or int. This newly created field
            will be attached to the attribute, so that modifications to one will change the
            other.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            The command string is executed when the value of the slider or floatField
            changes.  It will be executed only once after a drag of the slider.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraButton : eb               (bool)          [create]
            Add an extra icon button to the end of this control.
        
        - extraButtonCommand : ebc       (script)        [create,edit]
            The command string is executed when the extra button is clicked.
        
        - extraButtonIcon : ebi          (unicode)       [create,query,edit]
            The icon file name of the extra button.
        
        - fieldMaxValue : fmx            (float)         [create,query,edit]
            Set the maximum value for the field.  This flag allows you to specify a maximum
            bound for the field higher than that of the slider.   (See note above about max
            and min values.)
        
        - fieldMinValue : fmn            (float)         [create,query,edit]
            Set the minimum value for the field.  This flag allows you to specify a minimum
            bound for the field lower than that of the slider.  (See note above about max
            and min values.)
        
        - fieldStep : fs                 (float)         [create,query,edit]
            Sets the increment for the float field.
        
        - forceAddMapButton : fmb        (bool)          [create]
            Force adding a map button to this control. If this option is true, option
            hideMapButton is suppressed.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - hideMapButton : hmb            (bool)          [create]
            Force the map button to remain hidden for this control.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            By default, the label of this field will be the name of the attribute.  This
            flag can be used to override that name with whatever string you want.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (float)         [create,query,edit]
            Sets the maximum value for both the slider and the field. (See note above about
            min and max values)
        
        - minValue : min                 (float)         [create,query,edit]
            Sets the minimum value for both the slider and the field. (by default max and
            min are set according to what is in the attribute, if anything.  If no max and
            min are specified, or if only one of the two are specified, then no slider is
            created.)
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [create,edit]
            Sets the number of digits to the right of the decimal. (If attached to an int
            attribute, this is automatically set to 0 and cannot be overridden.)
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - sliderMaxValue : smx           (float)         [create,query,edit]
            Set the maximum value for the slider.  The slider max will be clipped to the
            field max.
        
        - sliderMinValue : smn           (float)         [create,query,edit]
            Set the minimum value for the slider.  The slider min will be clipped to the
            field min.
        
        - sliderStep : ss                (float)         [create,query,edit]
            On Linux the slider step value represents the amount the value will increase or
            decrease when you click either side of the slider.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            Sets the increment for both the slider and float field.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - vertical : vr                  (bool)          [create,query]
            Whether the orientation of the controls in this group are horizontal (default)
            or vertical.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attrFieldSliderGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attrFieldSliderGrp'
    
    
    __melui__ = 'attrFieldSliderGrp'


class AttrNavigationControlGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def extraButtonCommand(self, val='True', **kwargs):
        """
        The command string is executed when the extra button is clicked.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getAttrNavDecision(self, **kwargs):
        """
        The first argument is the name of an attribute. The button will be attached to the attribute so the button can be kept in synch with the attribute.  The second argument is the navigatorDecisionString that can guide the behaviour that the navigator implements.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        The name of an attribute. The button will be attached to the attribute so the button can be kept in synch with the attribute.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getConnectAttrToDropped(self, **kwargs):
        """
        The script to execute when a node is dragged and dropped onto an attribute (multilister dnd attribute editor). Your script should take in two arguments: the source node and destination attribute respectively.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getConnectNodeToDropped(self, **kwargs):
        """
        The script to execute when a node is dragged and dropped onto a node (the multilister issues this).  Your script should take in two arguments: the source node and destination node respectively.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getConnectToExisting(self, **kwargs):
        """
        The script to execute when a connection should be made to an existing node.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getCreateNew(self, **kwargs):
        """
        The script to execute when a new connectionis requested.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getDefaultTraversal(self, **kwargs):
        """
        The script to execute to find out the name of the default traversal node.  The script you attach should be able to take in one argument (the attribute) and return the name of the node that is the default traversal node.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getDelete(self, **kwargs):
        """
        The script to execute when the connection (and the node connected to) should be deleted.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getDisconnect(self, **kwargs):
        """
        The script to execute when a disconnectionis requested.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getExtraButtonIcon(self, **kwargs):
        """
        The icon file name of the extra button.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getIgnore(self, **kwargs):
        """
        The script to execute when the connection should be ignored.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Text for the control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getRelatedNodes(self, **kwargs):
        """
        The script to execute to find out what the related nodes are.  The script you attach should be able to take in one argument (the attribute) and return a list of strings that are the name of the nodes that are related.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getUnignore(self, **kwargs):
        """
        The script to execute when the connection should be unignored.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def noIgnorableMenu(self, val='True', **kwargs):
        """
        Not show ignorable related popup menu when right click the label.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def noKeyableMenu(self, val='True', **kwargs):
        """
        Not show keyable related popup menu when right click the label.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setAttrNavDecision(self, val='True', **kwargs):
        """
        The first argument is the name of an attribute. The button will be attached to the attribute so the button can be kept in synch with the attribute.  The second argument is the navigatorDecisionString that can guide the behaviour that the navigator implements.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        The name of an attribute. The button will be attached to the attribute so the button can be kept in synch with the attribute.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setConnectAttrToDropped(self, val='True', **kwargs):
        """
        The script to execute when a node is dragged and dropped onto an attribute (multilister dnd attribute editor). Your script should take in two arguments: the source node and destination attribute respectively.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setConnectNodeToDropped(self, val='True', **kwargs):
        """
        The script to execute when a node is dragged and dropped onto a node (the multilister issues this).  Your script should take in two arguments: the source node and destination node respectively.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setConnectToExisting(self, val='True', **kwargs):
        """
        The script to execute when a connection should be made to an existing node.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setCreateNew(self, val='True', **kwargs):
        """
        The script to execute when a new connectionis requested.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setDefaultTraversal(self, val='True', **kwargs):
        """
        The script to execute to find out the name of the default traversal node.  The script you attach should be able to take in one argument (the attribute) and return the name of the node that is the default traversal node.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setDelete(self, val='True', **kwargs):
        """
        The script to execute when the connection (and the node connected to) should be deleted.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setDisconnect(self, val='True', **kwargs):
        """
        The script to execute when a disconnectionis requested.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setExtraButtonIcon(self, val='True', **kwargs):
        """
        The icon file name of the extra button.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setIgnore(self, val='True', **kwargs):
        """
        The script to execute when the connection should be ignored.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Text for the control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setRelatedNodes(self, val='True', **kwargs):
        """
        The script to execute to find out what the related nodes are.  The script you attach should be able to take in one argument (the attribute) and return a list of strings that are the name of the nodes that are related.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setUnignore(self, val='True', **kwargs):
        """
        The script to execute when the connection should be unignored.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged label navigation button. The group is used to
        help the user manage connections to a particular attribute. When creating the
        control you have the opportunity to attach scripts to the control that are
        executed on various UI events.  You can define what happens when the navigation
        button is pressed, and when a node is dragged and dropped onto this attribute.
        The navigation button can traverse to the connected node or can bring up UI to
        create new connections to the attribute. The button also can show you state
        information: if there already exists a connection/if the connection is ignored.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attrNavDecision : attrNavDecision (PyNode, <type 'unicode'>) [create,query,edit]
            The first argument is the name of an attribute. The button will be attached to
            the attribute so the button can be kept in synch with the attribute.  The second
            argument is the navigatorDecisionString that can guide the behaviour that the
            navigator implements.
        
        - attribute : at                 (PyNode)        [create,query,edit]
            The name of an attribute. The button will be attached to the attribute so the
            button can be kept in synch with the attribute.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - connectAttrToDropped : cad     (script)        [create,query,edit]
            The script to execute when a node is dragged and dropped onto an attribute
            (multilister dnd attribute editor). Your script should take in two arguments:
            the source node and destination attribute respectively.
        
        - connectNodeToDropped : cnd     (script)        [create,query,edit]
            The script to execute when a node is dragged and dropped onto a node (the
            multilister issues this).  Your script should take in two arguments: the source
            node and destination node respectively.
        
        - connectToExisting : ce         (script)        [create,query,edit]
            The script to execute when a connection should be made to an existing node.
        
        - createNew : cn                 (script)        [create,query,edit]
            The script to execute when a new connectionis requested.
        
        - defaultTraversal : dtv         (script)        [create,query,edit]
            The script to execute to find out the name of the default traversal node.  The
            script you attach should be able to take in one argument (the attribute) and
            return the name of the node that is the default traversal node.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - delete : delete                (unicode)       [create,query,edit]
            The script to execute when the connection (and the node connected to) should be
            deleted.
        
        - disconnect : d                 (script)        [create,query,edit]
            The script to execute when a disconnectionis requested.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraButton : eb               (bool)          [create]
            Add an extra icon button to the last of this control.
        
        - extraButtonCommand : ebc       (script)        [create,edit]
            The command string is executed when the extra button is clicked.
        
        - extraButtonIcon : ebi          (unicode)       [create,query,edit]
            The icon file name of the extra button.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - ignore : i                     (script)        [create,query,edit]
            The script to execute when the connection should be ignored.
        
        - ignoreNotSupported : ins       (bool)          []
            Obsolete flag; has no effect.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Text for the control.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - noIgnorableMenu : nim          (bool)          [create,edit]
            Not show ignorable related popup menu when right click the label.
        
        - noKeyableMenu : nkm            (bool)          [create,edit]
            Not show keyable related popup menu when right click the label.
        
        - notIgnorableMenu : nim         (bool)          []
        
        - notKeyableMenu : nkm           (bool)          []
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - relatedNodes : ren             (script)        [create,query,edit]
            The script to execute to find out what the related nodes are.  The script you
            attach should be able to take in one argument (the attribute) and return a list
            of strings that are the name of the nodes that are related.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - unignore : u                   (script)        [create,query,edit]
            The script to execute when the connection should be unignored.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attrNavigationControlGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attrNavigationControlGrp'
    
    
    __melui__ = 'attrNavigationControlGrp'


class PaneLayout(Layout):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getActiveFrameThickness(self, **kwargs):
        """
        The thickness of the frame drawn around the active frame. Specify an integer value greater than or equal to 0.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getActivePane(self, **kwargs):
        """
        The active pane has a colored border surrounding it.  Only one pane may be active at any one time.  Using either of the flags -ap/activePaneor -api/activePaneIndexwill automatically deactivate the previously active pane.  The argument is the full or short name of the child control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getActivePaneIndex(self, **kwargs):
        """
        The active pane index.  The active pane has a colored border surrounding it.  Only one pane may be active at any one time.  Using either of the flags -ap/activePaneor -api/activePaneIndexwill automatically deactivate the previously active pane.  The argument is an integer value ranging from 1 to 4.  Panes for any particular configuration are numbered clockwise beginning with the pane in the top left corner of the layout.  If any other index is specified then the current active pane is deactivated.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getConfiguration(self, **kwargs):
        """
        Set the layout configuration for the panes.  Valid values are: single, horizontal2, vertical2, horizontal3, vertical3, top3, left3, bottom3, right3, horizontal4, vertical4, top4, left4, bottom4, right4, quad
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getNumberOfVisiblePanes(self, **kwargs):
        """
        Return the number of panes visible for the present configuration.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPane1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPane2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPane3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPane4(self, **kwargs):
        """
        Return the name of the control in the respective pane.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPaneSize(self, **kwargs):
        """
        The size of a pane in the current pane layout configuration.  The first argument specifies the pane index and is an integer value ranging from 1 to 4.  Panes for any particular configuration are numbered clockwise beginning with the pane in the top left corner of the layout.  The width and height of the pane are specified by the last two arguments.  Both are integer values and they indicate the percentage of the total pane layout size rather that the number of pixels.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPaneUnderPointer(self, **kwargs):
        """
        Return the name of the child occupying the pane that the pointer is currently over.  An empty string is returned if the pointer is not over a pane.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getSeparatorThickness(self, **kwargs):
        """
        The thickness of the separators between the panes. Specify an integer value greater than 0. This flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def separatorMovedCommand(self, val='True', **kwargs):
        """
        This command executed when the pane separators are moved.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setActiveFrameThickness(self, val='True', **kwargs):
        """
        The thickness of the frame drawn around the active frame. Specify an integer value greater than or equal to 0.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setActivePane(self, val='True', **kwargs):
        """
        The active pane has a colored border surrounding it.  Only one pane may be active at any one time.  Using either of the flags -ap/activePaneor -api/activePaneIndexwill automatically deactivate the previously active pane.  The argument is the full or short name of the child control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setActivePaneIndex(self, val='True', **kwargs):
        """
        The active pane index.  The active pane has a colored border surrounding it.  Only one pane may be active at any one time.  Using either of the flags -ap/activePaneor -api/activePaneIndexwill automatically deactivate the previously active pane.  The argument is an integer value ranging from 1 to 4.  Panes for any particular configuration are numbered clockwise beginning with the pane in the top left corner of the layout.  If any other index is specified then the current active pane is deactivated.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setConfiguration(self, val='True', **kwargs):
        """
        Set the layout configuration for the panes.  Valid values are: single, horizontal2, vertical2, horizontal3, vertical3, top3, left3, bottom3, right3, horizontal4, vertical4, top4, left4, bottom4, right4, quad
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setPane(self, val='True', **kwargs):
        """
        This flag allows you to put a child of this layout in a particular pane.  The first argument is the full or short name of the control.  The second argument is an integer value ranging from 1 to 4.  Panes for any particular configuration are numbered clockwise beginning with the pane in the top left corner of the layout.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setPaneSize(self, val='True', **kwargs):
        """
        The size of a pane in the current pane layout configuration.  The first argument specifies the pane index and is an integer value ranging from 1 to 4.  Panes for any particular configuration are numbered clockwise beginning with the pane in the top left corner of the layout.  The width and height of the pane are specified by the last two arguments.  Both are integer values and they indicate the percentage of the total pane layout size rather that the number of pixels.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setSeparatorThickness(self, val='True', **kwargs):
        """
        The thickness of the separators between the panes. Specify an integer value greater than 0. This flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def staticHeightPane(self, val='True', **kwargs):
        """
        Set a pane to have a static height, i.e. its height will not change when the layout is dynamically resized. Only one pane can be set to have a static height at one time. This state will be retained even if another child is switched into the pane. Specify 0 to set a pane back to the default state. Any state will be lost if the pane configuration is changed.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def staticWidthPane(self, val='True', **kwargs):
        """
        Set a pane to have a static width, i.e. its width will not change when the layout is dynamically resized. Only one pane can be set to have a static width at one time. This state will be retained even if another child is switched into the pane. Specify 0 to set a pane back to the default state. Any state will be lost if the pane configuration is changed.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a pane layout.  A pane layout may have any number of
        children but at any one time only certain children may be visible, as determined
        by the current layout configuration.  For example a horizontally split pane
        shows only two children, one on top of the other and a visible separator between
        the two.  The separator may be moved to vary the size of each pane.  Various
        other pane configurations are available and all display a moveable separator
        that define the size of each pane in the layout.
        
        Flags:
        - activeFrameThickness : aft     (int)           [create,query,edit]
            The thickness of the frame drawn around the active frame. Specify an integer
            value greater than or equal to 0.
        
        - activePane : ap                (unicode)       [create,query,edit]
            The active pane has a colored border surrounding it.  Only one pane may be
            active at any one time.  Using either of the flags -ap/activePaneor
            -api/activePaneIndexwill automatically deactivate the previously active pane.
            The argument is the full or short name of the child control.
        
        - activePaneIndex : api          (int)           [create,query,edit]
            The active pane index.  The active pane has a colored border surrounding it.
            Only one pane may be active at any one time.  Using either of the flags
            -ap/activePaneor -api/activePaneIndexwill automatically deactivate the
            previously active pane.  The argument is an integer value ranging from 1 to 4.
            Panes for any particular configuration are numbered clockwise beginning with the
            pane in the top left corner of the layout.  If any other index is specified then
            the current active pane is deactivated.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - configuration : cn             (unicode)       [create,query,edit]
            Set the layout configuration for the panes.  Valid values are: single,
            horizontal2, vertical2, horizontal3, vertical3, top3, left3, bottom3, right3,
            horizontal4, vertical4, top4, left4, bottom4, right4, quad
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - numberOfVisiblePanes : nvp     (bool)          [query]
            Return the number of panes visible for the present configuration.
        
        - pane1 : p1                     (bool)          [query]
        
        - pane2 : p2                     (bool)          [query]
        
        - pane3 : p3                     (bool)          [query]
        
        - pane4 : p4                     (bool)          [query]
            Return the name of the control in the respective pane.
        
        - paneSize : ps                  (int, int, int) [create,query,edit]
            The size of a pane in the current pane layout configuration.  The first argument
            specifies the pane index and is an integer value ranging from 1 to 4.  Panes for
            any particular configuration are numbered clockwise beginning with the pane in
            the top left corner of the layout.  The width and height of the pane are
            specified by the last two arguments.  Both are integer values and they indicate
            the percentage of the total pane layout size rather that the number of pixels.
        
        - paneUnderPointer : pup         (bool)          [query]
            Return the name of the child occupying the pane that the pointer is currently
            over.  An empty string is returned if the pointer is not over a pane.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - separatorMovedCommand : smc    (script)        [create,edit]
            This command executed when the pane separators are moved.
        
        - separatorThickness : st        (int)           [create,query,edit]
            The thickness of the separators between the panes. Specify an integer value
            greater than 0. This flag has no effect on Windows systems.
        
        - setPane : sp                   (unicode, int)  [create,edit]
            This flag allows you to put a child of this layout in a particular pane.  The
            first argument is the full or short name of the control.  The second argument is
            an integer value ranging from 1 to 4.  Panes for any particular configuration
            are numbered clockwise beginning with the pane in the top left corner of the
            layout.
        
        - staticHeightPane : shp         (int)           [create,edit]
            Set a pane to have a static height, i.e. its height will not change when the
            layout is dynamically resized. Only one pane can be set to have a static height
            at one time. This state will be retained even if another child is switched into
            the pane. Specify 0 to set a pane back to the default state. Any state will be
            lost if the pane configuration is changed.
        
        - staticWidthPane : swp          (int)           [create,edit]
            Set a pane to have a static width, i.e. its width will not change when the
            layout is dynamically resized. Only one pane can be set to have a static width
            at one time. This state will be retained even if another child is switched into
            the pane. Specify 0 to set a pane back to the default state. Any state will be
            lost if the pane configuration is changed.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.paneLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'paneLayout'
    
    
    __melui__ = 'paneLayout'


class AttrColorSliderGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getAttrNavDecision(self, **kwargs):
        """
        The first argument is the name of an attribute. The button will be attached to the attribute so the button can be kept in synch with the attribute.  The second argument is the navigatorDecisionString that can guide the behaviour that the navigator implements.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        The name of a unique attribute of type 3double.  This newly created field will be attached to the attribute, so that modifications to one will change the other.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getHsvValue(self, **kwargs):
        """
        Specifies the color in hsv style.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        By default, the label of this field will be the name of the attribute.  This flag can be used to override that name with whatever the user wants.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getRgbValue(self, **kwargs):
        """
        Specifies the color in rgb style.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getShowButton(self, **kwargs):
        """
        Control the display of the texture link button. True by default (show it).                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setAttrNavDecision(self, val='True', **kwargs):
        """
        The first argument is the name of an attribute. The button will be attached to the attribute so the button can be kept in synch with the attribute.  The second argument is the navigatorDecisionString that can guide the behaviour that the navigator implements.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        The name of a unique attribute of type 3double.  This newly created field will be attached to the attribute, so that modifications to one will change the other.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setHsvValue(self, val='True', **kwargs):
        """
        Specifies the color in hsv style.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        By default, the label of this field will be the name of the attribute.  This flag can be used to override that name with whatever the user wants.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setRgbValue(self, val='True', **kwargs):
        """
        Specifies the color in rgb style.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setShowButton(self, val='True', **kwargs):
        """
        Control the display of the texture link button. True by default (show it).                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. Create
        a color slider group consisting of a label, a color canvas, a slider and a
        button.  Clicking on the canvas will bring up the color editor.  If the button
        is visible, it will allow you to map a texture to the attribute.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attrNavDecision : attrNavDecision (PyNode, <type 'unicode'>) [create,query,edit]
            The first argument is the name of an attribute. The button will be attached to
            the attribute so the button can be kept in synch with the attribute.  The second
            argument is the navigatorDecisionString that can guide the behaviour that the
            navigator implements.
        
        - attribute : at                 (unicode)       [create,query,edit]
            The name of a unique attribute of type 3double.  This newly created field will
            be attached to the attribute, so that modifications to one will change the
            other.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - hsvValue : hsv                 (float, float, float) [create,query,edit]
            Specifies the color in hsv style.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            By default, the label of this field will be the name of the attribute.  This
            flag can be used to override that name with whatever the user wants.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rgbValue : rgb                 (float, float, float) [create,query,edit]
            Specifies the color in rgb style.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - showButton : sb                (bool)          [create,query,edit]
            Control the display of the texture link button. True by default (show it).
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attrColorSliderGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attrColorSliderGrp'
    
    
    __melui__ = 'attrColorSliderGrp'


class TextFieldButtonGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def buttonCommand(self, val='True', **kwargs):
        """
        Command attached to the button.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the field text changes and user presses Enter or Return.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def forceChangeCommand(self, val='True', **kwargs):
        """
        If used together with -text or -inserText flag, change command will be executed after text modification.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getButtonLabel(self, **kwargs):
        """
        Label text of the button.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/textflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getEnableButton(self, **kwargs):
        """
        Enable state of the button.  By default, this flag is set to true and the button is enabled.  Specify true, and the button will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getFileName(self, **kwargs):
        """
        Text in the field as a filename. This does conversions between internal and external (UI) file representation.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getInsertionPosition(self, **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getPlaceholderText(self, **kwargs):
        """
        Setting this property makes the line edit display a grayed-out placeholder text as long as the text field is empty and the widget doesn't have focus. By default, this property contains an empty string.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getText(self, **kwargs):
        """
        Text in the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def insertText(self, val='True', **kwargs):
        """
        Insert text into the field at the current insertion position (specified by the -ip/insertionPosition flag).                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setButtonLabel(self, val='True', **kwargs):
        """
        Label text of the button.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the field.  By default, this flag is set to true and the field value may be changed by typing into it. If false then the field is 'read only' and can not be typed into. The text in the field can always be changed with the -tx/textflag regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setEnableButton(self, val='True', **kwargs):
        """
        Enable state of the button.  By default, this flag is set to true and the button is enabled.  Specify true, and the button will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setFileName(self, val='True', **kwargs):
        """
        Text in the field as a filename. This does conversions between internal and external (UI) file representation.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setInsertionPosition(self, val='True', **kwargs):
        """
        The insertion position for inserted text.  This is a 1 based value where position 1 specifies the beginning of the field.  Position 0 may be used to specify the end of the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setPlaceholderText(self, val='True', **kwargs):
        """
        Setting this property makes the line edit display a grayed-out placeholder text as long as the text field is empty and the widget doesn't have focus. By default, this property contains an empty string.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setText(self, val='True', **kwargs):
        """
        Text in the field.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    def textChangedCommand(self, val='True', **kwargs):
        """
        Command executed immediately when the field text changes.                  
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command adds a button to the textFieldGrp command.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - buttonCommand : bc             (script)        [create,edit]
            Command attached to the button.
        
        - buttonLabel : bl               (unicode)       [create,query,edit]
            Label text of the button.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the field text changes and user presses Enter or Return.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the field.  By default, this flag is set to true and the field
            value may be changed by typing into it. If false then the field is 'read only'
            and can not be typed into. The text in the field can always be changed with the
            -tx/textflag regardless of the state of the -ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableButton : eb              (bool)          [create,query,edit]
            Enable state of the button.  By default, this flag is set to true and the button
            is enabled.  Specify true, and the button will appear dimmed or greyed-out
            indicating it is disabled.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fileName : fi                  (unicode)       [create,query,edit]
            Text in the field as a filename. This does conversions between internal and
            external (UI) file representation.
        
        - forceChangeCommand : fcc       (bool)          [create,edit]
            If used together with -text or -inserText flag, change command will be executed
            after text modification.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - insertText : it                (unicode)       [create,edit]
            Insert text into the field at the current insertion position (specified by the
            -ip/insertionPosition flag).
        
        - insertionPosition : ip         (int)           [create,query,edit]
            The insertion position for inserted text.  This is a 1 based value where
            position 1 specifies the beginning of the field.  Position 0 may be used to
            specify the end of the field.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Label text for the group.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - placeholderText : pht          (unicode)       [create,query,edit]
            Setting this property makes the line edit display a grayed-out placeholder text
            as long as the text field is empty and the widget doesn't have focus. By
            default, this property contains an empty string.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - text : tx                      (unicode)       [create,query,edit]
            Text in the field.
        
        - textChangedCommand : tcc       (script)        [create,edit]
            Command executed immediately when the field text changes.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.textFieldButtonGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'textFieldButtonGrp'
    
    
    __melui__ = 'textFieldButtonGrp'


class ColorIndexSliderGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes.  This command is not invoked when the value changes via the -v/value flag.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command executed when the value changes by dragging the slider's value marker.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getForceDragRefresh(self, **kwargs):
        """
        If used then force refresh on drag                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getInvisible(self, **kwargs):
        """
        Set the invisible color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Maximum color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Minimum color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getValue(self, **kwargs):
        """
        Color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setForceDragRefresh(self, val='True', **kwargs):
        """
        If used then force refresh on drag                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setInvisible(self, val='True', **kwargs):
        """
        Set the invisible color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Maximum color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Minimum color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Color index.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a color slider group consisting of a label, a color canvas and a
        slider. The value of the slider defines a color index into the a color table.
        The corresponding color is displayed in the canvas.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the value changes.  This command is not invoked when the
            value changes via the -v/value flag.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command executed when the value changes by dragging the slider's value marker.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            Sets the string to be the text for the extra label.
        
        - forceDragRefresh : fdr         (bool)          [create,query,edit]
            If used then force refresh on drag
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - invisible : inv                (int)           [create,query,edit]
            Set the invisible color index.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Label text for the group.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (int)           [create,query,edit]
            Maximum color index.
        
        - minValue : min                 (int)           [create,query,edit]
            Minimum color index.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (int)           [create,query,edit]
            Color index.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.colorIndexSliderGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'colorIndexSliderGrp'
    
    
    __melui__ = 'colorIndexSliderGrp'


class FormLayout(Layout):
    def __init__(self, name='None', orientation="'vertical'", spacing='2', reversed='False', ratios='None', **kwargs):
        """
        spacing - absolute space between controls
        orientation - the orientation of the layout [ AutoLayout.HORIZONTAL | AutoLayout.VERTICAL ]
        """
        pass
    def attachControl(self, *args): pass
    def attachForm(self, *args): pass
    def attachNone(self, *args): pass
    def attachOppositeControl(self, val='True', **kwargs):
        """
        Arguments are: control, edge, offset, control Valid edge values are: top| bottom| left| right. Attach a control to the opposite side of another control.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def attachOppositeForm(self, val='True', **kwargs):
        """
        Arguments are: control, edge, offset. Valid edge values are: top| bottom| left| right. Attach a control to the opposite side of the form.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def attachPosition(self, *args): pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def flip(self):
        """
        Flip the orientation of the layout
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getNumberOfDivisions(self, **kwargs):
        """
        Specify the number of horizontal and vertical divisions across the form. Value must be greater than 0.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def hDistribute(self, *ratios): pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def redistribute(self, *ratios):
        """
        Redistribute the child controls based on the ratios.
        If not ratios are given (or not enough), 1 will be used
        """
        pass
    def reset(self): pass
    def reverse(self):
        """
        Reverse the children order
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setNumberOfDivisions(self, val='True', **kwargs):
        """
        Specify the number of horizontal and vertical divisions across the form. Value must be greater than 0.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    def vDistribute(self, *ratios): pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a form layout control. A form layout allows absolute and
        relative positioning of the controls that are its immediate children. Controls
        have four edges: top, left, bottom and right. There are only two directions that
        children can be positioned in, right-left and up-down. The attach flags take the
        direction of an attachment from the argument that names the edge to attach (the
        second argument). Any or all edges of a child may be attached. There are six
        ways to attach them: Attach to Form - Attaches an edge to the relevant side of
        the form layout. Thus -attachForm button3 leftwill attach the left edge of the
        button to the left edge of the form.Attach to Opposite Side of Form - Attaches
        an edge relative to the furthest side of the form layout.Attach to Another
        Control - Attaches an edge to the closest edge of the other control named.Attach
        to Opposite Side of Another Control - Attaches an edge relative to the furthest
        side of another control.Attach to Position - Attaches an edge to a position on
        the form layout.  The position is given as a fixed fraction of the
        -nd/numDivisions value and as this value defaults to 100 it is easiest to think
        of it as a percentage of the form's size.Attach to Nothing - Attaches an edge to
        nothing. The size of the child control will determine this edge's position.Each
        edge attachment may have an offset that acts to separate controls visually.
        There is no default positioning relationship so to have children appear in the
        form they must have at least one edge attached in each direction. Note:In the
        flag definitions the arguments follow these rules: controlmust be the name of an
        immediate child of the form layout.edgemust be one of top, left, bottom, or
        right.positionmay range from 0 to the number of divisions as specified with the
        -nd/numberOfDivisions flag and gives the fraction of the width of the form as a
        measurement. This normally means 0-100 so  positionmay be thought of as a
        percentage.offsetis an integer value in pixels.These are multi-use flags so any
        number of attachments may be made in a single command. Note:Avoid making control
        attachments that form a loop in control dependencies. For example: window;
        string $form = `formLayout`; string $btn1 = `button`; string $btn2 = `button`;
        string $btn3 = `button`;formLayout -edit-attachControl $btn2 top2
        $btn1-attachControl $btn3 top2 $btn2-attachControl $btn1 right2 $btn3
        $form;showWindow; $btn2 is attached to $btn1, $btn3 is attached to $btn2, and
        $btn1 is attached to $btn3. Thus, the placement of $btn1 is dependent on the
        placement of $btn3, which is dependent on the placement of $btn2, which is
        dependent on the placement of $btn1. The last control attachment will have
        created a loop in the dependencies. To prevent runtime errors, Maya will ignore
        this attachment and instead issue a warning that a cyclical control attachment
        has been detected in the script.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attachControl : ac             (unicode, unicode, int, unicode) [create,edit]
            Arguments are: control, edge, offset, control Valid edge values are: top|
            bottom| left| right. Attach a control to another control.
        
        - attachForm : af                (unicode, unicode, int) [create,edit]
            Arguments are: control, edge, offset. Valid edge values are: top| bottom| left|
            right. Attach the specified control to the form, offset by the specified amount.
        
        - attachNone : an                (unicode, unicode) [create,edit]
            Arguments are: control, edge Valid edge values are: top| bottom| left| right.
            Attach a control to nothing.
        
        - attachOppositeControl : aoc    (unicode, unicode, int, unicode) [create,edit]
            Arguments are: control, edge, offset, control Valid edge values are: top|
            bottom| left| right. Attach a control to the opposite side of another control.
        
        - attachOppositeForm : aof       (unicode, unicode, int) [create,edit]
            Arguments are: control, edge, offset. Valid edge values are: top| bottom| left|
            right. Attach a control to the opposite side of the form.
        
        - attachPosition : ap            (unicode, unicode, int, int) [create,edit]
            Arguments are: control, edge, offset, position Valid edge values are: top|
            bottom| left| right. Attach a control to a position in the form.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfDivisions : nd         (int)           [create,query,edit]
            Specify the number of horizontal and vertical divisions across the form. Value
            must be greater than 0.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.formLayout`
        """
        pass
    @staticmethod
    def __new__(cls, name='None', **kwargs): pass
    HORIZONTAL = 0
    
    
    Orientation = {}
    
    
    VERTICAL = 1
    
    
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'formLayout'
    
    
    __melui__ = 'formLayout'


class AttrFieldGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        The command string is executed when the value of any of the floatFields change.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def extraButtonCommand(self, val='True', **kwargs):
        """
        The command string is executed when the extra button is clicked.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getAttribute(self, **kwargs):
        """
        The name of a unique attribute of type vector.  This newly created field will be attached to the attribute, so that modifications to one will change the other.  A vectorattribute is any compound attribute whose children consist of two to four double-valued attributes.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getExtraButtonIcon(self, **kwargs):
        """
        The icon file name of the extra button.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        set an optional string that will be positioned to the right of all the fields.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        By default, the label of this field will be the name of the attribute.  This flag can be used to override that name with whatever the user wants.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Sets the maximum value for all fields.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Sets the minimum value for all fields.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getStep(self, **kwargs):
        """
        Sets the increment for all fields                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def precision(self, val='True', **kwargs):
        """
        Sets the precision for all fields                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setAttribute(self, val='True', **kwargs):
        """
        The name of a unique attribute of type vector.  This newly created field will be attached to the attribute, so that modifications to one will change the other.  A vectorattribute is any compound attribute whose children consist of two to four double-valued attributes.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setExtraButtonIcon(self, val='True', **kwargs):
        """
        The icon file name of the extra button.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        set an optional string that will be positioned to the right of all the fields.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        By default, the label of this field will be the name of the attribute.  This flag can be used to override that name with whatever the user wants.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Sets the maximum value for all fields.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Sets the minimum value for all fields.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Sets the increment for all fields                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of label text, plus two to four float
        fields.  These fields will be attached to the specified vector attribute, so
        that changes in either will be reflected in the other. The fields created here
        are expression fields -- while normally operating as a float field, the user can
        type in any expression starting with the character -. The field also has an
        automatic menu brought up by the right mouse button.  The contents of this menu
        change depending on the state of the attribute being watched by the field.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - attribute : at                 (unicode)       [create,query,edit]
            The name of a unique attribute of type vector.  This newly created field will be
            attached to the attribute, so that modifications to one will change the other.
            A vectorattribute is any compound attribute whose children consist of two to
            four double-valued attributes.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            The command string is executed when the value of any of the floatFields change.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraButton : eb               (bool)          [create]
            Add an extra icon button to the end of this control (before extra label).
        
        - extraButtonCommand : ebc       (script)        [create,edit]
            The command string is executed when the extra button is clicked.
        
        - extraButtonIcon : ebi          (unicode)       [create,query,edit]
            The icon file name of the extra button.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            set an optional string that will be positioned to the right of all the fields.
        
        - forceAddMapButton : fmb        (bool)          [create]
            Force adding a map button to this control. If this option is true, option
            hideMapButton is suppressed.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - hideMapButton : hmb            (bool)          [create]
            Force the map button to remain hidden for this control.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            By default, the label of this field will be the name of the attribute.  This
            flag can be used to override that name with whatever the user wants.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (float)         [create,query,edit]
            Sets the maximum value for all fields.
        
        - minValue : min                 (float)         [create,query,edit]
            Sets the minimum value for all fields.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfFields : nf            (int)           [create]
            sets the number of fields.  Only allowed values are 2 to 4.  If not specified,
            defaults to 3.  NOTE: if the -at flag is used when this widget is created, the
            number of children in the attribute will determine the number of fields.  Also
            note:  after creation, the number of fields cannot be changed with the -e flag.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [create,edit]
            Sets the precision for all fields
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            Sets the increment for all fields
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.attrFieldGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'attrFieldGrp'
    
    
    __melui__ = 'attrFieldGrp'


class ColorSliderGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command string executed when slider value changes.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command string executed when slider value marker is dragged.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getForceDragRefresh(self, **kwargs):
        """
        If used then force refresh on drag                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getHsvValue(self, **kwargs):
        """
        Color in hue, saturation, and value format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getRgbValue(self, **kwargs):
        """
        Color in red, green, and blue format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setForceDragRefresh(self, val='True', **kwargs):
        """
        If used then force refresh on drag                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setHsvValue(self, val='True', **kwargs):
        """
        Color in hue, saturation, and value format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        Label text for the group.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setRgbValue(self, val='True', **kwargs):
        """
        Color in red, green, and blue format.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a color Slider group consisting of a label, a color canvas and a
        slider.  Clicking on the canvas will bring up the color editor dialog.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command string executed when slider value changes.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command string executed when slider value marker is dragged.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - forceDragRefresh : fdr         (bool)          [create,query,edit]
            If used then force refresh on drag
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - hsvValue : hsv                 (float, float, float) [create,query,edit]
            Color in hue, saturation, and value format.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            Label text for the group.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rgbValue : rgb                 (float, float, float) [create,query,edit]
            Color in red, green, and blue format.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.colorSliderGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'colorSliderGrp'
    
    
    __melui__ = 'colorSliderGrp'


class RadioButtonGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the group changes state. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of a radio button from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def changeCommand1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def changeCommand2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def changeCommand3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def changeCommand4(self, val='True', **kwargs):
        """
        Specify a changed state command for each respective radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getAnnotation1(self, **kwargs):
        """
        specifies the tooptip of the first radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getAnnotation2(self, **kwargs):
        """
        specifies the tooptip of the second radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getAnnotation3(self, **kwargs):
        """
        specifies the tooptip of the third radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getAnnotation4(self, **kwargs):
        """
        specifies the tooptip of the fourth radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getData1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getData2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getData3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getData4(self, **kwargs):
        """
        Internal data associated with each radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the group.  By default, this flag is set to true and the radio button values may be changed by clicking on them.  If false then the radio buttons are 'read only' and can not be clicked on. The value of the radio button can always be changed with the sl/selectflags regardless of the state of the ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEnable1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEnable2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEnable3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEnable4(self, **kwargs):
        """
        Enable state of the individual radio buttons.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        When present on creation an optional text label will be built with the group.  The string specifies the label text.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabel1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabel2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabel3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabel4(self, **kwargs):
        """
        Specify label strings for the respective radio buttons in the group.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabelAnnotation(self, **kwargs):
        """
        when present on creation an optional text label will be built with the group . The string specifies the label tooltip                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabelArray2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabelArray3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getLabelArray4(self, **kwargs):
        """
        Specify multiple labels in a single flag.  These flags are ignored if the number of radio buttons doesn't match.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Selected radio button.  The argument is a 1 based integer.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getVertical(self, **kwargs):
        """
        Whether the orientation of the radio buttons in this group are horizontal (default) or vertical.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def offCommand(self, val='True', **kwargs):
        """
        Command executed when any radio button turns off.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def offCommand1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def offCommand2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def offCommand3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def offCommand4(self, val='True', **kwargs):
        """
        Off command for each respective radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def onCommand(self, val='True', **kwargs):
        """
        Command executed when any radio button turns on.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def onCommand1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def onCommand2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def onCommand3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def onCommand4(self, val='True', **kwargs):
        """
        On command for each respective radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setAnnotation1(self, val='True', **kwargs):
        """
        specifies the tooptip of the first radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setAnnotation2(self, val='True', **kwargs):
        """
        specifies the tooptip of the second radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setAnnotation3(self, val='True', **kwargs):
        """
        specifies the tooptip of the third radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setAnnotation4(self, val='True', **kwargs):
        """
        specifies the tooptip of the fourth radiobutton                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setData1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setData2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setData3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setData4(self, val='True', **kwargs):
        """
        Internal data associated with each radio button.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the group.  By default, this flag is set to true and the radio button values may be changed by clicking on them.  If false then the radio buttons are 'read only' and can not be clicked on. The value of the radio button can always be changed with the sl/selectflags regardless of the state of the ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEnable1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEnable2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEnable3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEnable4(self, val='True', **kwargs):
        """
        Enable state of the individual radio buttons.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        When present on creation an optional text label will be built with the group.  The string specifies the label text.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabel1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabel2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabel3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabel4(self, val='True', **kwargs):
        """
        Specify label strings for the respective radio buttons in the group.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabelAnnotation(self, val='True', **kwargs):
        """
        when present on creation an optional text label will be built with the group . The string specifies the label tooltip                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabelArray2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabelArray3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setLabelArray4(self, val='True', **kwargs):
        """
        Specify multiple labels in a single flag.  These flags are ignored if the number of radio buttons doesn't match.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Selected radio button.  The argument is a 1 based integer.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates from one to four radio buttons in a single row. By default the
        radio buttons will share a single collection, but they can also share the
        collection of another radio button group.  The buttons can also have an optional
        text label.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - annotation1 : an1              (unicode)       [create,query,edit]
            specifies the tooptip of the first radiobutton
        
        - annotation2 : an2              (unicode)       [create,query,edit]
            specifies the tooptip of the second radiobutton
        
        - annotation3 : an3              (unicode)       [create,query,edit]
            specifies the tooptip of the third radiobutton
        
        - annotation4 : an4              (unicode)       [create,query,edit]
            specifies the tooptip of the fourth radiobutton
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the group changes state. Note that this flag should not be
            used in conjunction with onCommand and offCommand. That is, one should either
            use changeCommand and test the state of a radio button from inside the callback,
            or use onCommand and offCommand as separate callbacks.
        
        - changeCommand1 : cc1           (script)        [create,edit]
        
        - changeCommand2 : cc2           (script)        [create,edit]
        
        - changeCommand3 : cc3           (script)        [create,edit]
        
        - changeCommand4 : cc4           (script)        [create,edit]
            Specify a changed state command for each respective radio button.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - data1 : da1                    (int)           [create,query,edit]
        
        - data2 : da2                    (int)           [create,query,edit]
        
        - data3 : da3                    (int)           [create,query,edit]
        
        - data4 : da4                    (int)           [create,query,edit]
            Internal data associated with each radio button.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the group.  By default, this flag is set to true and the radio
            button values may be changed by clicking on them.  If false then the radio
            buttons are 'read only' and can not be clicked on. The value of the radio button
            can always be changed with the sl/selectflags regardless of the state of the
            ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enable1 : en1                  (bool)          [create,query,edit]
        
        - enable2 : en2                  (bool)          [create,query,edit]
        
        - enable3 : en3                  (bool)          [create,query,edit]
        
        - enable4 : en4                  (bool)          [create,query,edit]
            Enable state of the individual radio buttons.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            When present on creation an optional text label will be built with the group.
            The string specifies the label text.
        
        - label1 : l1                    (unicode)       [create,query,edit]
        
        - label2 : l2                    (unicode)       [create,query,edit]
        
        - label3 : l3                    (unicode)       [create,query,edit]
        
        - label4 : l4                    (unicode)       [create,query,edit]
            Specify label strings for the respective radio buttons in the group.
        
        - labelAnnotation : la           (unicode)       [create,query,edit]
            when present on creation an optional text label will be built with the group .
            The string specifies the label tooltip
        
        - labelArray2 : la2              (unicode, unicode) [create,query,edit]
        
        - labelArray3 : la3              (unicode, unicode, unicode) [create,query,edit]
        
        - labelArray4 : la4              (unicode, unicode, unicode, unicode) [create,query,edit]
            Specify multiple labels in a single flag.  These flags are ignored if the number
            of radio buttons doesn't match.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - numberOfRadioButtons : nrb     (int)           [create]
            Number of radio buttons in the group (1 - 4).
        
        - offCommand : ofc               (script)        [create,edit]
            Command executed when any radio button turns off.
        
        - offCommand1 : of1              (script)        [create,edit]
        
        - offCommand2 : of2              (script)        [create,edit]
        
        - offCommand3 : of3              (script)        [create,edit]
        
        - offCommand4 : of4              (script)        [create,edit]
            Off command for each respective radio button.
        
        - onCommand : onc                (script)        [create,edit]
            Command executed when any radio button turns on.
        
        - onCommand1 : on1               (script)        [create,edit]
        
        - onCommand2 : on2               (script)        [create,edit]
        
        - onCommand3 : on3               (script)        [create,edit]
        
        - onCommand4 : on4               (script)        [create,edit]
            On command for each respective radio button.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - select : sl                    (int)           [create,query,edit]
            Selected radio button.  The argument is a 1 based integer.
        
        - shareCollection : scl          (unicode)       [create]
            Specify the radioButtonGrp that this radio group is to be associated with.  By
            default the radio group will be a separate collection.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - vertical : vr                  (bool)          [create,query]
            Whether the orientation of the radio buttons in this group are horizontal
            (default) or vertical.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.radioButtonGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'radioButtonGrp'
    
    
    __melui__ = 'radioButtonGrp'


class CheckBoxGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when the group changes state. Note that this flag should not be used in conjunction with onCommand and offCommand. That is, one should either use changeCommand and test the state of a check box from inside the callback, or use onCommand and offCommand as separate callbacks.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def changeCommand1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def changeCommand2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def changeCommand3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def changeCommand4(self, val='True', **kwargs):
        """
        Specify a changed state command for each respective check box.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEditable(self, **kwargs):
        """
        The edit state of the group.  By default, this flag is set to true and the check box values may be changed by clicking on them.  If false then the check boxes are 'read only' and can not be clicked on. The value of the check boxes can always be changed with the -v/valueflags regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEnable1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEnable2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEnable3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEnable4(self, **kwargs):
        """
        Enable state of the individual check boxes.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        When present on creation an optional text label will be built with the group.  The string specifes the label text.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabel1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabel2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabel3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabel4(self, **kwargs):
        """
        Specify label strings for the respective check boxes in the group.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabelArray2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabelArray3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getLabelArray4(self, **kwargs):
        """
        Specify multiple labels in a single flag.  These flags are ignored if the number of radio buttons doesn't match.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getValue1(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getValue2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getValue3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getValue4(self, **kwargs):
        """
        Values for the respective check boxes in the group.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getValueArray2(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getValueArray3(self, **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getValueArray4(self, **kwargs):
        """
        Specifies multiple values in a single flag.  These flags are ignored if the number of check boxes doesn't match.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getVertical(self, **kwargs):
        """
        Whether the orientation of the checkbox controls in this group are horizontal (default) or vertical.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def offCommand(self, val='True', **kwargs):
        """
        Command executed when any check box turns off.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def offCommand1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def offCommand2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def offCommand3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def offCommand4(self, val='True', **kwargs):
        """
        Off command for each respective check box.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def onCommand(self, val='True', **kwargs):
        """
        Command executed when any check box turns on.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def onCommand1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def onCommand2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def onCommand3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def onCommand4(self, val='True', **kwargs):
        """
        On command for each respective check box.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEditable(self, val='True', **kwargs):
        """
        The edit state of the group.  By default, this flag is set to true and the check box values may be changed by clicking on them.  If false then the check boxes are 'read only' and can not be clicked on. The value of the check boxes can always be changed with the -v/valueflags regardless of the state of the -ed/editableflag.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEnable1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEnable2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEnable3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEnable4(self, val='True', **kwargs):
        """
        Enable state of the individual check boxes.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        When present on creation an optional text label will be built with the group.  The string specifes the label text.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabel1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabel2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabel3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabel4(self, val='True', **kwargs):
        """
        Specify label strings for the respective check boxes in the group.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabelArray2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabelArray3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setLabelArray4(self, val='True', **kwargs):
        """
        Specify multiple labels in a single flag.  These flags are ignored if the number of radio buttons doesn't match.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setValue1(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setValue2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setValue3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setValue4(self, val='True', **kwargs):
        """
        Values for the respective check boxes in the group.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setValueArray2(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setValueArray3(self, val='True', **kwargs):
        """
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setValueArray4(self, val='True', **kwargs):
        """
        Specifies multiple values in a single flag.  These flags are ignored if the number of check boxes doesn't match.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates from one to four check boxes in a single row. They can have an
        optional text label. TelfBaseGrpCmd.cpp
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when the group changes state. Note that this flag should not be
            used in conjunction with onCommand and offCommand. That is, one should either
            use changeCommand and test the state of a check box from inside the callback, or
            use onCommand and offCommand as separate callbacks.
        
        - changeCommand1 : cc1           (script)        [create,edit]
        
        - changeCommand2 : cc2           (script)        [create,edit]
        
        - changeCommand3 : cc3           (script)        [create,edit]
        
        - changeCommand4 : cc4           (script)        [create,edit]
            Specify a changed state command for each respective check box.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - editable : ed                  (bool)          [create,query,edit]
            The edit state of the group.  By default, this flag is set to true and the check
            box values may be changed by clicking on them.  If false then the check boxes
            are 'read only' and can not be clicked on. The value of the check boxes can
            always be changed with the -v/valueflags regardless of the state of the
            -ed/editableflag.
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enable1 : en1                  (bool)          [create,query,edit]
        
        - enable2 : en2                  (bool)          [create,query,edit]
        
        - enable3 : en3                  (bool)          [create,query,edit]
        
        - enable4 : en4                  (bool)          [create,query,edit]
            Enable state of the individual check boxes.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            When present on creation an optional text label will be built with the group.
            The string specifes the label text.
        
        - label1 : l1                    (unicode)       [create,query,edit]
        
        - label2 : l2                    (unicode)       [create,query,edit]
        
        - label3 : l3                    (unicode)       [create,query,edit]
        
        - label4 : l4                    (unicode)       [create,query,edit]
            Specify label strings for the respective check boxes in the group.
        
        - labelArray2 : la2              (unicode, unicode) [create,query,edit]
        
        - labelArray3 : la3              (unicode, unicode, unicode) [create,query,edit]
        
        - labelArray4 : la4              (unicode, unicode, unicode, unicode) [create,query,edit]
            Specify multiple labels in a single flag.  These flags are ignored if the number
            of radio buttons doesn't match.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfCheckBoxes : ncb       (int)           [create]
            Number of check boxes in the group (1 - 4).
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - offCommand : ofc               (script)        [create,edit]
            Command executed when any check box turns off.
        
        - offCommand1 : of1              (script)        [create,edit]
        
        - offCommand2 : of2              (script)        [create,edit]
        
        - offCommand3 : of3              (script)        [create,edit]
        
        - offCommand4 : of4              (script)        [create,edit]
            Off command for each respective check box.
        
        - onCommand : onc                (script)        [create,edit]
            Command executed when any check box turns on.
        
        - onCommand1 : on1               (script)        [create,edit]
        
        - onCommand2 : on2               (script)        [create,edit]
        
        - onCommand3 : on3               (script)        [create,edit]
        
        - onCommand4 : on4               (script)        [create,edit]
            On command for each respective check box.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value1 : v1                    (bool)          [create,query,edit]
        
        - value2 : v2                    (bool)          [create,query,edit]
        
        - value3 : v3                    (bool)          [create,query,edit]
        
        - value4 : v4                    (bool)          [create,query,edit]
            Values for the respective check boxes in the group.
        
        - valueArray2 : va2              (bool, bool)    [create,query,edit]
        
        - valueArray3 : va3              (bool, bool, bool) [create,query,edit]
        
        - valueArray4 : va4              (bool, bool, bool, bool) [create,query,edit]
            Specifies multiple values in a single flag.  These flags are ignored if the
            number of check boxes doesn't match.
        
        - vertical : vr                  (bool)          [create,query]
            Whether the orientation of the checkbox controls in this group are horizontal
            (default) or vertical.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.checkBoxGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'checkBoxGrp'
    
    
    __melui__ = 'checkBoxGrp'


class ScrollLayout(Layout):
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getBorderVisible(self, **kwargs):
        """
        Visibility of the border.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getChildArray(self, **kwargs):
        """
        Returns a string array of the names of the layout's immediate children.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getChildResizable(self, **kwargs):
        """
        Set to true if you want the child of the control layout to be as wide as the scroll area.  You may also indicate a minimum width for the child using the -mcw/minChildWidthflag.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getMinChildWidth(self, **kwargs):
        """
        A positive non-zero integer value indicating the minimum width the scroll layout's child.  This flag only has meaning when the -cr/childResizableflag is set to true.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getNumberOfChildren(self, **kwargs):
        """
        Returns in an int the number of immediate children of the layout.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getPanEnabled(self, **kwargs):
        """
        Set to true if you want to pan the scroll layout using ALT + MMB. On OSX, in one button and two button mode, you could use command+alt+LMB to pan it. The pan effect is disabled by default.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getScrollAreaHeight(self, **kwargs):
        """
        Return the height of the scroll area (in pixels).                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getScrollAreaValue(self, **kwargs):
        """
        Return the vertical and horizontal values of the scroll area (in pixels).                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getScrollAreaWidth(self, **kwargs):
        """
        Return the width of the scroll area (in pixels).                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def horizontalScrollBarThickness(self, val='True', **kwargs):
        """
        Thickness of the horizontal scroll bar.  Specify an integer value of pixels greater than or equal to 0. Other than setting the value to 0 to hide the scrollbar, this flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def resizeCommand(self, val='True', **kwargs):
        """
        The command invoked when the scroll layout is resized.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def scrollByPixel(self, val='True', **kwargs):
        """
        Scroll the client area in the direction of the string. The int specifies the number of pixels.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def scrollPage(self, val='True', **kwargs):
        """
        Scroll the client area in the direction of the string. Valid values are up, down, leftor right.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setBorderVisible(self, val='True', **kwargs):
        """
        Visibility of the border.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setPanEnabled(self, val='True', **kwargs):
        """
        Set to true if you want to pan the scroll layout using ALT + MMB. On OSX, in one button and two button mode, you could use command+alt+LMB to pan it. The pan effect is disabled by default.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    def verticalScrollBarThickness(self, val='True', **kwargs):
        """
        Thickness of the vertical scroll bar.  Specify an integer value of pixels greater than or equal to 0. This flag has no effect on Windows systems.                  
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        This command creates a scroll layout.  A scroll layout is useful for when you
        have a number of controls which cannot all be visible at a time.  This layout
        will display a horizontal and/or vertical scroll bar when necessary to bring
        into view the hidden controls. Since the scroll layout provides no real
        positioning of children you should use another control layout as the immediate
        child.
        
        Flags:
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - borderVisible : bv             (bool)          [create,query,edit]
            Visibility of the border.
        
        - childArray : ca                (bool)          [query]
            Returns a string array of the names of the layout's immediate children.
        
        - childResizable : cr            (bool)          [create,query]
            Set to true if you want the child of the control layout to be as wide as the
            scroll area.  You may also indicate a minimum width for the child using the
            -mcw/minChildWidthflag.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - horizontalScrollBarThickness : hst (int)           [create,edit]
            Thickness of the horizontal scroll bar.  Specify an integer value of pixels
            greater than or equal to 0. Other than setting the value to 0 to hide the
            scrollbar, this flag has no effect on Windows systems.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - minChildWidth : mcw            (int)           [create,query]
            A positive non-zero integer value indicating the minimum width the scroll
            layout's child.  This flag only has meaning when the -cr/childResizableflag is
            set to true.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfChildren : nch         (bool)          [query]
            Returns in an int the number of immediate children of the layout.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - panEnabled : pe                (bool)          [query,edit]
            Set to true if you want to pan the scroll layout using ALT + MMB. On OSX, in one
            button and two button mode, you could use command+alt+LMB to pan it. The pan
            effect is disabled by default.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - resizeCommand : rc             (script)        [create,edit]
            The command invoked when the scroll layout is resized.
        
        - scrollAreaHeight : sah         (bool)          [query]
            Return the height of the scroll area (in pixels).
        
        - scrollAreaValue : sav          (bool)          [query]
            Return the vertical and horizontal values of the scroll area (in pixels).
        
        - scrollAreaWidth : saw          (bool)          [query]
            Return the width of the scroll area (in pixels).
        
        - scrollByPixel : sbp            (unicode, int)  [edit]
            Scroll the client area in the direction of the string. The int specifies the
            number of pixels.
        
        - scrollPage : sp                (unicode)       [edit]
            Scroll the client area in the direction of the string. Valid values are up,
            down, leftor right.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - verticalScrollBarAlwaysVisible : vsb (bool)          [create]
            Set to true if you want to always have the vertical scroll bar visible.
        
        - verticalScrollBarThickness : vst (int)           [create,edit]
            Thickness of the vertical scroll bar.  Specify an integer value of pixels
            greater than or equal to 0. This flag has no effect on Windows systems.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.scrollLayout`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'scrollLayout'
    
    
    __melui__ = 'scrollLayout'


class FloatSliderGrp(Layout):
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command string executed when the value of the slider changes.  It will be executed only once after a drag of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def dragCommand(self, val='True', **kwargs):
        """
        Command string executed repeatedly during a drag of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be an extra label appearing after the slider.  Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getFieldMaxValue(self, **kwargs):
        """
        Maximum value that may be entered in the field.  This value may be set to any value greater than the -max/maxValueflag.  By default, it is equal to the -max/maxValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getFieldMinValue(self, **kwargs):
        """
        Minimum value that may be entered in the field.  This value may be set to any value less than the -min/minValueflag.  By default, it is equal to the -min/minValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getFieldStep(self, **kwargs):
        """
        Increment for the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        If present on creation the group will have static text.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getMaxValue(self, **kwargs):
        """
        Maximum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getMinValue(self, **kwargs):
        """
        Minimum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getSliderStep(self, **kwargs):
        """
        The slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getStep(self, **kwargs):
        """
        Increment for both the slider and field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getValue(self, **kwargs):
        """
        Value of the group.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def precision(self, val='True', **kwargs):
        """
        Number of digits to the right of the decimal.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be an extra label appearing after the slider.  Sets the string to be the text for the extra label.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setFieldMaxValue(self, val='True', **kwargs):
        """
        Maximum value that may be entered in the field.  This value may be set to any value greater than the -max/maxValueflag.  By default, it is equal to the -max/maxValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setFieldMinValue(self, val='True', **kwargs):
        """
        Minimum value that may be entered in the field.  This value may be set to any value less than the -min/minValueflag.  By default, it is equal to the -min/minValueflag.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setFieldStep(self, val='True', **kwargs):
        """
        Increment for the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        If present on creation the group will have static text.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setMaxValue(self, val='True', **kwargs):
        """
        Maximum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setMinValue(self, val='True', **kwargs):
        """
        Minimum value for both the slider and the field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setSliderStep(self, val='True', **kwargs):
        """
        The slider step value represents the amount the value will increase or decrease when you click either side of the slider.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setStep(self, val='True', **kwargs):
        """
        Increment for both the slider and field.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Value of the group.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of controls containing a label text,
        an float field and a float slider. The text and field controls are optional.
        Editing or querying the field range values has no effect if the -f/fieldflag was
        not specified when the group was created. This group also allows you to enter
        values into the field outside of the slider range which is limited by the
        -min/minValueand -max/maxValueflags.  To do this, use the -fmn/fieldMinValueand
        -fmx/fieldMaxValueflags to specify a greater range of values. Note that the
        command will not allow you to specify a -fmn/fieldMinValuegreater than the
        -min/minValuevalue nor a -fmx/fieldMaxValueless than the -max/maxValuevalue. If
        you do supply a larger field range with the -fmn/fieldMinValueand
        -fmx/fieldMaxValueflags then you will notice that entering a value in the field
        that is outside of the slider range will result in extending the slider range as
        well.  For example, if you create a slider group with the following command:
        floatSliderGrp -min -10 -max 10 -fieldMinValue -100 -fieldMaxValue 100; Then you
        will be able to use the slider to select any value from -10 to 10. At the same
        time you will be able to enter into the field any value from -100 to 100.  If
        you enter a value, say 20, then the new slider range will grow such that this
        value is now accessible through the slider as well.  In fact, the new slider
        limit will become double of that what you entered.  Note that the slider limits
        will never grow beyond the field limits, in other words if you entered the value
        80 then the slider will be clipped to the field limit of 100 and not doubled to
        160.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command string executed when the value of the slider changes.  It will be
            executed only once after a drag of the slider.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dragCommand : dc               (script)        [create,edit]
            Command string executed repeatedly during a drag of the slider.
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            If present on creation this specifies that there will be an extra label
            appearing after the slider.  Sets the string to be the text for the extra label.
        
        - field : f                      (bool)          [create]
            Indicates whether the group will have an editable float field present that
            reflects the value of the slider.
        
        - fieldMaxValue : fmx            (float)         [create,query,edit]
            Maximum value that may be entered in the field.  This value may be set to any
            value greater than the -max/maxValueflag.  By default, it is equal to the
            -max/maxValueflag.
        
        - fieldMinValue : fmn            (float)         [create,query,edit]
            Minimum value that may be entered in the field.  This value may be set to any
            value less than the -min/minValueflag.  By default, it is equal to the
            -min/minValueflag.
        
        - fieldStep : fs                 (float)         [create,query,edit]
            Increment for the field.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - label : l                      (unicode)       [create,query,edit]
            If present on creation the group will have static text.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - maxValue : max                 (float)         [create,query,edit]
            Maximum value for both the slider and the field.
        
        - minValue : min                 (float)         [create,query,edit]
            Minimum value for both the slider and the field.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - precision : pre                (int)           [create,edit]
            Number of digits to the right of the decimal.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - sliderStep : ss                (float)         [create,query,edit]
            The slider step value represents the amount the value will increase or decrease
            when you click either side of the slider.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - step : s                       (float)         [create,query,edit]
            Increment for both the slider and field.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (float)         [create,query,edit]
            Value of the group.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.floatSliderGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'floatSliderGrp'
    
    
    __melui__ = 'floatSliderGrp'


class VectorFieldGrp(FloatFieldGrp):
    def getVector(self): pass
    def setVector(self, vec): pass
    @staticmethod
    def __new__(cls, name='None', create='False', *args, **kwargs): pass


class OptionMenuGrp(RowLayout):
    def __enter__(self):
        """
        # Want to set both the menu to the child |OptionMenu item, and the normal
        # parent to this...
        """
        pass
    def __exit__(self, type, value, traceback): pass
    def adjustableColumn(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the sizing of the layout.  The column value is a 1-based index. Passing 0 as argument turns off the previous adjustable column.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def adjustableColumn2(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def adjustableColumn3(self, val='True', **kwargs):
        """
        Specifies that the column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def adjustableColumn4(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def adjustableColumn5(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def adjustableColumn6(self, val='True', **kwargs):
        """
        Specifies which column has an adjustable size that changes with the size of the parent layout. Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def changeCommand(self, val='True', **kwargs):
        """
        Command executed when a new item is selected.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAlign(self, val='True', **kwargs):
        """
        Arguments are : column number, alignment type. Possible alignments are: left | right | center. Specifies alignment type for the specified column.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAlign2(self, val='True', **kwargs):
        """
        Sets the text alignment of both columns.  Ignored if there are not exactly two columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAlign3(self, val='True', **kwargs):
        """
        Sets the text alignment for all three columns.  Ignored if there are not exactly three columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAlign4(self, val='True', **kwargs):
        """
        Sets the text alignment for all four columns.  Ignored if there are not exactly four columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAlign5(self, val='True', **kwargs):
        """
        Sets the text alignment for all five columns.  Ignored if there are not exactly five columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAlign6(self, val='True', **kwargs):
        """
        Sets the text alignment for all six columns.  Ignored if there are not exactly six columns. Valid values are left, right, and center.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAttach(self, val='True', **kwargs):
        """
        Arguments are : column number, attachment type, and offset. Possible attachments are: left | right | both. Specifies column attachment types and offets.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAttach2(self, val='True', **kwargs):
        """
        Sets the attachment type of both columns. Ignored if there are not exactly two columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAttach3(self, val='True', **kwargs):
        """
        Sets the attachment type for all three columns. Ignored if there are not exactly three columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAttach4(self, val='True', **kwargs):
        """
        Sets the attachment type for all four columns. Ignored if there are not exactly four columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAttach5(self, val='True', **kwargs):
        """
        Sets the attachment type for all five columns. Ignored if there are not exactly five columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnAttach6(self, val='True', **kwargs):
        """
        Sets the attachment type for all six columns. Ignored if there are not exactly six columns. Valid values are left, right, and both.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnOffset2(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach2 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the two columns.  The offsets applied are based on the attachments specified with the -columnAttach2 flag.  Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnOffset3(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach3 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the three columns.  The offsets applied are based on the attachments specified with the -columnAttach3 flag.  Ignored if there are not exactly three columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnOffset4(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach4 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the four columns.  The offsets applied are based on the attachments specified with the -columnAttach4 flag.  Ignored if there are not exactly four columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnOffset5(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach5 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the five columns.  The offsets applied are based on the attachments specified with the -columnAttach5 flag.  Ignored if there are not exactly five columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnOffset6(self, val='True', **kwargs):
        """
        This flag is used in conjunction with the -columnAttach6 flag.  If that flag is not used then this flag will be ignored.  It sets the offset for the six columns.  The offsets applied are based on the attachments specified with the -columnAttach6 flag.  Ignored if there are not exactly six columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnWidth(self, val='True', **kwargs):
        """
        Arguments are : column number, column width. Sets the width of the specified column where the first parameter specifies the column (1 based index) and the second parameter specifies the width.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnWidth1(self, val='True', **kwargs):
        """
        Sets the width of the first column. Ignored if there is not exactly one column.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnWidth2(self, val='True', **kwargs):
        """
        Sets the column widths of both columns. Ignored if there are not exactly two columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnWidth3(self, val='True', **kwargs):
        """
        Sets the column widths for all 3 columns. Ignored if there are not exactly 3 columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnWidth4(self, val='True', **kwargs):
        """
        Sets the column widths for all 4 columns. Ignored if there are not exactly 4 columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnWidth5(self, val='True', **kwargs):
        """
        Sets the column widths for all 5 columns. Ignored if there are not exactly 5 columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def columnWidth6(self, val='True', **kwargs):
        """
        Sets the column widths for all 6 columns. Ignored if there are not exactly 6 columns.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def dragCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when the middle mouse button is pressed.  The MEL version of the callback is of the form: global proc string[] callbackName(string $dragControl, int $x, int $y, int $mods) The proc returns a string array that is transferred to the drop site. By convention the first string in the array describes the user settable message type.  Controls that are application defined drag sources may ignore the callback. $mods allows testing for the key modifiers CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3 == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def callbackName( dragControl, x, y, modifiers ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, x, y, modifiers.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(x)d %(y)d %(modifiers)d'
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def dropCallback(self, val='True', **kwargs):
        """
        Adds a callback that is called when a drag and drop operation is released above the drop site.  The MEL version of the callback is of the form: global proc callbackName(string $dragControl, string $dropControl, string $msgs[], int $x, int $y, int $type) The proc receives a string array that is transferred from the drag source. The first string in the msgs array describes the user defined message type. Controls that are application defined drop sites may ignore the callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python, it is similar, but there are two ways to specify the callback.  The recommended way is to pass a Python function object as the argument.  In that case, the Python callback should have the form: def pythonDropTest( dragControl, dropControl, messages, x, y, dragType ): The values of these arguments are the same as those for the MEL version above. The other way to specify the callback in Python is to specify a string to be executed.  In that case, the string will have the values substituted into it via the standard Python format operator.  The format values are passed in a dictionary with the keys dragControl, dropControl, messages, x, y, type.  The dragControlvalue is a string and the other values are integers (eg the callback string could be print '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getAnnotation(self, **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getBackgroundColor(self, **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getDocTag(self, **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getEnable(self, **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getEnableBackground(self, **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getEnableKeyboardFocus(self, **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getExtraLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be an extra label to the right of the option menu.  Sets the string to be the extra label text.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getFullPathName(self, **kwargs):
        """
        Return the full path name of the widget, which includes all the parents.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getHeight(self, **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getHighlightColor(self, **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getIsObscured(self, **kwargs):
        """
        Return whether the control can actually be seen by the user. The control will be obscured if its state is invisible, if it is blocked (entirely or partially) by some other control, if it or a parent layout is unmanaged, or if the control's window is invisible or iconified.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getItemListLong(self, **kwargs):
        """
        Returns the long names of the items.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getItemListShort(self, **kwargs):
        """
        Returns the short names of the items.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getLabel(self, **kwargs):
        """
        If present on creation this specifies that there will be a label to the left of the option menu.  Sets the string to be the label text.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getManage(self, **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getNumberOfItems(self, **kwargs):
        """
        Returns the number of items.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getNumberOfPopupMenus(self, **kwargs):
        """
        Return the number of popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getPopupMenuArray(self, **kwargs):
        """
        Return the names of all the popup menus attached to this control.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getPreventOverride(self, **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getSelect(self, **kwargs):
        """
        Selects an item by index.  The first item is 1.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getValue(self, **kwargs):
        """
        Select an item by value.  Also, returns the text of the currently selected item.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getVisible(self, **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getVisibleChangeCommand(self, **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def getWidth(self, **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def menu(self): pass
    def noBackground(self, val='True', **kwargs):
        """
        Clear/reset the control's background. Passing true means the background should not be drawn at all, false means the background should be drawn.  The state of this flag is inherited by children of this control.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def rowAttach(self, val='True', **kwargs):
        """
        Arguments are : column, attachment type, offset. Possible attachments are: top | bottom | both. Specifies attachment types and offsets for the entire row.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setAnnotation(self, val='True', **kwargs):
        """
        Annotate the control with an extra string value.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setBackgroundColor(self, val='True', **kwargs):
        """
        The background color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0. When setting backgroundColor, the background is automatically enabled, unless enableBackground is also specified with a false value.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setDocTag(self, val='True', **kwargs):
        """
        Add a documentation flag to the control.  The documentation flag has a directory structure. (e.g., -dt render/multiLister/createNode/material)                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setEnable(self, val='True', **kwargs):
        """
        The enable state of the control.  By default, this flag is set to true and the control is enabled.  Specify false and the control will appear dimmed or greyed-out indicating it is disabled.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setEnableBackground(self, val='True', **kwargs):
        """
        Enables the background color of the control.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setEnableKeyboardFocus(self, val='True', **kwargs):
        """
        If enabled, the user can navigate to the control with the tab key and select values with the keyboard. If not, the user can only use the mouse. This flag would typically be used to turn off keyboard focus support from controls that get it by default, like Edit and List controls                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setExtraLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be an extra label to the right of the option menu.  Sets the string to be the extra label text.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setHeight(self, val='True', **kwargs):
        """
        The height of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setHighlightColor(self, val='True', **kwargs):
        """
        The highlight color of the control. The arguments correspond to the red, green, and blue color components. Each component ranges in value from 0.0 to 1.0.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setLabel(self, val='True', **kwargs):
        """
        If present on creation this specifies that there will be a label to the left of the option menu.  Sets the string to be the label text.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setManage(self, val='True', **kwargs):
        """
        Manage state of the control.  An unmanaged control is not visible, nor does it take up any screen real estate.  All controls are created managed by default.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setPreventOverride(self, val='True', **kwargs):
        """
        If true, this flag prevents overriding the control's attribute via the control's right mouse button menu.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setSelect(self, val='True', **kwargs):
        """
        Selects an item by index.  The first item is 1.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setValue(self, val='True', **kwargs):
        """
        Select an item by value.  Also, returns the text of the currently selected item.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setVisible(self, val='True', **kwargs):
        """
        The visible state of the control.  A control is created visible by default.  Note that a control's actual appearance is also dependent on the visible state of its parent layout(s).                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setVisibleChangeCommand(self, val='True', **kwargs):
        """
        Command that gets executed when visible state of the control changes.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def setWidth(self, val='True', **kwargs):
        """
        The width of the control.  The control will attempt to be this size if it is not overruled by parent layout conditions.                  Flag can have multiple arguments, passed either as a tuple or a list.             
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    def statusBarMessage(self, val='True', **kwargs):
        """
        Extra string to display in the status bar when the mouse is over the control.                  
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    @staticmethod
    def __melcmd__(*args, **kwargs):
        """
        All of the group commands position their individual controls in columns starting
        at column 1.  The layout of each control (ie. column) can be customized using
        the -cw/columnWidth, -co/columnOffset, -cat/columnAttach, -cal/columnAlign, and
        -adj/adjustableColumnflags.  By default, columns are left aligned with no offset
        and are 100 pixels wide.  Only one column in any group can be adjustable. This
        command creates a pre-packaged collection of label text, option menu and an
        extra label.  Both the label and extra label are optional. Subsequent calls to
        the menuItem command will place them in the option menu.  When adding menu items
        to the option menu after the initialization step, use the name of the options
        menu itself. See the example below for more details. Note that commands attached
        to menu items will not get called. Use the -cc/changedCommandflag to be notified
        when the user changes the value of the option menu.
        
        Flags:
        - adjustableColumn : adj         (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the sizing of
            the layout.  The column value is a 1-based index. Passing 0 as argument turns
            off the previous adjustable column.
        
        - adjustableColumn2 : ad2        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly two columns.
        
        - adjustableColumn3 : ad3        (int)           [create,edit]
            Specifies that the column has an adjustable size that changes with the size of
            the parent layout. Ignored if there are not exactly three columns.
        
        - adjustableColumn4 : ad4        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly four columns.
        
        - adjustableColumn5 : ad5        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly five columns.
        
        - adjustableColumn6 : ad6        (int)           [create,edit]
            Specifies which column has an adjustable size that changes with the size of the
            parent layout. Ignored if there are not exactly six columns.
        
        - annotation : ann               (unicode)       [create,query,edit]
            Annotate the control with an extra string value.
        
        - backgroundColor : bgc          (float, float, float) [create,query,edit]
            The background color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0. When
            setting backgroundColor, the background is automatically enabled, unless
            enableBackground is also specified with a false value.
        
        - changeCommand : cc             (script)        [create,edit]
            Command executed when a new item is selected.
        
        - columnAlign : cal              (int, unicode)  [create,edit]
            Arguments are : column number, alignment type. Possible alignments are: left |
            right | center. Specifies alignment type for the specified column.
        
        - columnAlign2 : cl2             (unicode, unicode) [create,edit]
            Sets the text alignment of both columns.  Ignored if there are not exactly two
            columns. Valid values are left, right, and center.
        
        - columnAlign3 : cl3             (unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all three columns.  Ignored if there are not exactly
            three columns. Valid values are left, right, and center.
        
        - columnAlign4 : cl4             (unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all four columns.  Ignored if there are not exactly
            four columns. Valid values are left, right, and center.
        
        - columnAlign5 : cl5             (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all five columns.  Ignored if there are not exactly
            five columns. Valid values are left, right, and center.
        
        - columnAlign6 : cl6             (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the text alignment for all six columns.  Ignored if there are not exactly
            six columns. Valid values are left, right, and center.
        
        - columnAttach : cat             (int, unicode, int) [create,edit]
            Arguments are : column number, attachment type, and offset. Possible attachments
            are: left | right | both. Specifies column attachment types and offets.
        
        - columnAttach2 : ct2            (unicode, unicode) [create,edit]
            Sets the attachment type of both columns. Ignored if there are not exactly two
            columns. Valid values are left, right, and both.
        
        - columnAttach3 : ct3            (unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all three columns. Ignored if there are not exactly
            three columns. Valid values are left, right, and both.
        
        - columnAttach4 : ct4            (unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all four columns. Ignored if there are not exactly
            four columns. Valid values are left, right, and both.
        
        - columnAttach5 : ct5            (unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all five columns. Ignored if there are not exactly
            five columns. Valid values are left, right, and both.
        
        - columnAttach6 : ct6            (unicode, unicode, unicode, unicode, unicode, unicode) [create,edit]
            Sets the attachment type for all six columns. Ignored if there are not exactly
            six columns. Valid values are left, right, and both.
        
        - columnOffset2 : co2            (int, int)      [create,edit]
            This flag is used in conjunction with the -columnAttach2 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the two
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach2 flag.  Ignored if there are not exactly two columns.
        
        - columnOffset3 : co3            (int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach3 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the three
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach3 flag.  Ignored if there are not exactly three columns.
        
        - columnOffset4 : co4            (int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach4 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the four
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach4 flag.  Ignored if there are not exactly four columns.
        
        - columnOffset5 : co5            (int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach5 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the five
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach5 flag.  Ignored if there are not exactly five columns.
        
        - columnOffset6 : co6            (int, int, int, int, int, int) [create,edit]
            This flag is used in conjunction with the -columnAttach6 flag.  If that flag is
            not used then this flag will be ignored.  It sets the offset for the six
            columns.  The offsets applied are based on the attachments specified with the
            -columnAttach6 flag.  Ignored if there are not exactly six columns.
        
        - columnWidth : cw               (int, int)      [create,edit]
            Arguments are : column number, column width. Sets the width of the specified
            column where the first parameter specifies the column (1 based index) and the
            second parameter specifies the width.
        
        - columnWidth1 : cw1             (int)           [create,edit]
            Sets the width of the first column. Ignored if there is not exactly one column.
        
        - columnWidth2 : cw2             (int, int)      [create,edit]
            Sets the column widths of both columns. Ignored if there are not exactly two
            columns.
        
        - columnWidth3 : cw3             (int, int, int) [create,edit]
            Sets the column widths for all 3 columns. Ignored if there are not exactly 3
            columns.
        
        - columnWidth4 : cw4             (int, int, int, int) [create,edit]
            Sets the column widths for all 4 columns. Ignored if there are not exactly 4
            columns.
        
        - columnWidth5 : cw5             (int, int, int, int, int) [create,edit]
            Sets the column widths for all 5 columns. Ignored if there are not exactly 5
            columns.
        
        - columnWidth6 : cw6             (int, int, int, int, int, int) [create,edit]
            Sets the column widths for all 6 columns. Ignored if there are not exactly 6
            columns.
        
        - defineTemplate : dt            (unicode)       [create]
            Puts the command in a mode where any other flags and arguments are parsed and
            added to the command template specified in the argument. They will be used as
            default arguments in any subsequent invocations of the command when templateName
            is set as the current template.
        
        - docTag : dtg                   (unicode)       [create,query,edit]
            Add a documentation flag to the control.  The documentation flag has a directory
            structure. (e.g., -dt render/multiLister/createNode/material)
        
        - dragCallback : dgc             (script)        [create,edit]
            Adds a callback that is called when the middle mouse button is pressed.  The MEL
            version of the callback is of the form: global proc string[] callbackName(string
            $dragControl, int $x, int $y, int $mods) The proc returns a string array that is
            transferred to the drop site. By convention the first string in the array
            describes the user settable message type.  Controls that are application defined
            drag sources may ignore the callback. $mods allows testing for the key modifiers
            CTRL and SHIFT. Possible values are 0 == No modifiers, 1 == SHIFT, 2 == CTRL, 3
            == CTRL + SHIFT. In Python, it is similar, but there are two ways to specify the
            callback.  The recommended way is to pass a Python function object as the
            argument.  In that case, the Python callback should have the form: def
            callbackName( dragControl, x, y, modifiers ): The values of these arguments are
            the same as those for the MEL version above. The other way to specify the
            callback in Python is to specify a string to be executed.  In that case, the
            string will have the values substituted into it via the standard Python format
            operator.  The format values are passed in a dictionary with the keys
            dragControl, x, y, modifiers.  The dragControlvalue is a string and the other
            values are integers (eg the callback string could be print '%(dragControl)s
            %(x)d %(y)d %(modifiers)d'
        
        - dropCallback : dpc             (script)        [create,edit]
            Adds a callback that is called when a drag and drop operation is released above
            the drop site.  The MEL version of the callback is of the form: global proc
            callbackName(string $dragControl, string $dropControl, string $msgs[], int $x,
            int $y, int $type) The proc receives a string array that is transferred from the
            drag source. The first string in the msgs array describes the user defined
            message type. Controls that are application defined drop sites may ignore the
            callback. $type can have values of 1 == Move, 2 == Copy, 3 == Link. In Python,
            it is similar, but there are two ways to specify the callback.  The recommended
            way is to pass a Python function object as the argument.  In that case, the
            Python callback should have the form: def pythonDropTest( dragControl,
            dropControl, messages, x, y, dragType ): The values of these arguments are the
            same as those for the MEL version above. The other way to specify the callback
            in Python is to specify a string to be executed.  In that case, the string will
            have the values substituted into it via the standard Python format operator.
            The format values are passed in a dictionary with the keys dragControl,
            dropControl, messages, x, y, type.  The dragControlvalue is a string and the
            other values are integers (eg the callback string could be print
            '%(dragControl)s %(dropControl)s %(messages)r %(x)d %(y)d %(type)d'
        
        - enable : en                    (bool)          [create,query,edit]
            The enable state of the control.  By default, this flag is set to true and the
            control is enabled.  Specify false and the control will appear dimmed or greyed-
            out indicating it is disabled.
        
        - enableBackground : ebg         (bool)          [create,query,edit]
            Enables the background color of the control.
        
        - enableKeyboardFocus : ekf      (bool)          [create,query,edit]
            If enabled, the user can navigate to the control with the tab key and select
            values with the keyboard. If not, the user can only use the mouse. This flag
            would typically be used to turn off keyboard focus support from controls that
            get it by default, like Edit and List controls
        
        - exists : ex                    (bool)          [create]
            Returns whether the specified object exists or not. Other flags are ignored.
        
        - extraLabel : el                (unicode)       [create,query,edit]
            If present on creation this specifies that there will be an extra label to the
            right of the option menu.  Sets the string to be the extra label text.
        
        - fullPathName : fpn             (bool)          [query]
            Return the full path name of the widget, which includes all the parents.
        
        - height : h                     (int)           [create,query,edit]
            The height of the control.  The control will attempt to be this size if it is
            not overruled by parent layout conditions.
        
        - highlightColor : hlc           (float, float, float) [create,query,edit]
            The highlight color of the control. The arguments correspond to the red, green,
            and blue color components. Each component ranges in value from 0.0 to 1.0.
        
        - isObscured : io                (bool)          [query]
            Return whether the control can actually be seen by the user. The control will be
            obscured if its state is invisible, if it is blocked (entirely or partially) by
            some other control, if it or a parent layout is unmanaged, or if the control's
            window is invisible or iconified.
        
        - itemListLong : ill             (bool)          [query]
            Returns the long names of the items.
        
        - itemListShort : ils            (bool)          [query]
            Returns the short names of the items.
        
        - label : l                      (unicode)       [create,query,edit]
            If present on creation this specifies that there will be a label to the left of
            the option menu.  Sets the string to be the label text.
        
        - manage : m                     (bool)          [create,query,edit]
            Manage state of the control.  An unmanaged control is not visible, nor does it
            take up any screen real estate.  All controls are created managed by default.
        
        - noBackground : nbg             (bool)          [create,edit]
            Clear/reset the control's background. Passing true means the background should
            not be drawn at all, false means the background should be drawn.  The state of
            this flag is inherited by children of this control.
        
        - numberOfItems : ni             (bool)          [query]
            Returns the number of items.
        
        - numberOfPopupMenus : npm       (bool)          [query]
            Return the number of popup menus attached to this control.
        
        - parent : p                     (unicode)       [create,query]
            The parent layout for this control.
        
        - popupMenuArray : pma           (bool)          [query]
            Return the names of all the popup menus attached to this control.
        
        - preventOverride : po           (bool)          [create,query,edit]
            If true, this flag prevents overriding the control's attribute via the control's
            right mouse button menu.
        
        - rowAttach : rat                (int, unicode, int) [create,edit]
            Arguments are : column, attachment type, offset. Possible attachments are: top |
            bottom | both. Specifies attachment types and offsets for the entire row.
        
        - select : sl                    (int)           [create,query,edit]
            Selects an item by index.  The first item is 1.
        
        - statusBarMessage : sbm         (unicode)       [create,edit]
            Extra string to display in the status bar when the mouse is over the control.
        
        - useTemplate : ut               (unicode)       [create]
            Forces the command to use a command template other than the current one.
        
        - value : v                      (unicode)       [create,query,edit]
            Select an item by value.  Also, returns the text of the currently selected item.
        
        - visible : vis                  (bool)          [create,query,edit]
            The visible state of the control.  A control is created visible by default.
            Note that a control's actual appearance is also dependent on the visible state
            of its parent layout(s).
        
        - visibleChangeCommand : vcc     (script)        [create,query,edit]
            Command that gets executed when visible state of the control changes.
        
        - width : w                      (int)           [create,query,edit]
            The width of the control.  The control will attempt to be this size if it is not
            overruled by parent layout conditions.                  Flag can have multiple
            arguments, passed either as a tuple or a list.
        
        
        Derived from mel command `maya.cmds.optionMenuGrp`
        """
        pass
    __melcmd_isinfo__ = False
    
    
    __melcmdname__ = 'optionMenuGrp'
    
    
    __melui__ = 'optionMenuGrp'


class PathButtonGrp(TextFieldButtonGrp):
    def getPath(self): pass
    def setPath(self, path, **kwargs): pass
    @staticmethod
    def __new__(cls, name='None', create='False', *args, **kwargs): pass
    PROMPT_FUNCTION = 'promptForPath'


class AutoLayout(FormLayout):
    """
    AutoLayout behaves exactly like `FormLayout`, but will call redistribute automatically
    at the end of a 'with' statement block
    """
    
    
    
    def __exit__(self, type, value, traceback): pass


class FolderButtonGrp(PathButtonGrp):
    PROMPT_FUNCTION = 'promptForFolder'




def toPyQtWindow(mayaName):
    """
    Given the name of a May UI control, return the corresponding QWidget.
    If the object does not exist, returns None
    
    .. note:: Requires PyQt
    """
    pass
def toPyQtMenuItem(mayaName):
    """
    Given the name of a May UI menuItem, return the corresponding QAction.
    If the object does not exist, returns None
    
    This only works for menu items. for Menus, use toQtControl or toQtObject
    
    .. note:: Requires PyQt
    """
    pass
def toPySideObject(mayaName):
    """
    Given the name of a Maya UI element of any type, return the corresponding QWidget or QAction.
    If the object does not exist, returns None
    
    When using this function you don't need to specify whether UI type is a control, layout,
    window, or menuItem, the first match -- in that order -- will be returned. If you have the full path to a UI object
    this should always be correct, however, if you only have the short name of the UI object,
    consider using one of the more specific variants: `toQtControl`, `toQtLayout`, `toQtWindow`, or `toQtMenuItem`.
    
    .. note:: Requires PySide
    """
    pass
def MenuItem(name='None', create='False', **kwargs): pass
def _addTypeNames(): pass
def toPySideMenuItem(mayaName):
    """
    Given the name of a Maya UI menuItem, return the corresponding QAction.
    If the object does not exist, returns None
    
    This only works for menu items. for Menus, use toQtControl or toQtObject
    
    .. note:: Requires PySide
    """
    pass
def toPySideWindow(mayaName):
    """
    Given the name of a May UI control, return the corresponding QWidget.
    If the object does not exist, returns None
    
    .. note:: Requires PySide
    """
    pass
def toPyQtLayout(mayaName):
    """
    Given the name of a May UI control, return the corresponding QWidget.
    If the object does not exist, returns None
    
    .. note:: Requires PyQt
    """
    pass
def toPySideLayout(mayaName):
    """
    Given the name of a May UI control, return the corresponding QWidget.
    If the object does not exist, returns None
    
    .. note:: Requires PySide
    """
    pass
def _resolveUIFunc(name): pass
def toPySideControl(mayaName):
    """
    Given the name of a May UI control, return the corresponding QWidget.
    If the object does not exist, returns None
    
    .. note:: Requires PySide
    """
    pass
def toPyQtObject(mayaName):
    """
    Given the name of a Maya UI element of any type, return the corresponding QWidget or QAction.
    If the object does not exist, returns None
    
    When using this function you don't need to specify whether UI type is a control, layout,
    window, or menuItem, the first match -- in that order -- will be returned. If you have the full path to a UI object
    this should always be correct, however, if you only have the short name of the UI object,
    consider using one of the more specific variants: `toQtControl`, `toQtLayout`, `toQtWindow`, or `toQtMenuItem`.
    
    .. note:: Requires PyQt
    """
    pass
def toPyQtControl(mayaName):
    """
    Given the name of a May UI control, return the corresponding QWidget.
    If the object does not exist, returns None
    
    .. note:: Requires PyQt
    """
    pass
def pysideWrapInstance(ptr, base='None'):
    """
    Utility to convert a point to a Qt Class and produce the same result
    as sip.wrapinstance using shiboken.wrapInstance.
    
    Note: This is modeled after nathanhorne.com/?p=486. The base arg isn't
    currently used, and defaults to QObject. The way that base arg was used
    seems like it would give a different result than the sip version. It would
    skip the checking for attribute and just use base as base, however the sip
    version will still return QMainWindow even if QObject is passed in.
    """
    pass
def objectTypeUI(name, **kwargs):
    """
    This command returns the type of UI element such as button, sliders, etc.
    
    Flags:
    - isType : i                     (unicode)       [create]
        Returns true|false if the object is of the specified type.
    
    - listAll : la                   (bool)          [create]
        Returns a list of all known UI commands and their respective types. Each entry
        contains three strings which are the command name, ui type and class name. Note
        that the class name is internal and is subject to change.
    
    - superClasses : sc              (bool)          [create]
        Returns a list of the names of all super classes for the given object. Note that
        all class names are internal and are subject to change.                  Flag
        can have multiple arguments, passed either as a tuple or a list.
    
    
    Derived from mel command `maya.cmds.objectTypeUI`
    """
    pass


_withParentStack = []

mayaTypeNameToPymelTypeName = {}

_uiTypesToCommands = {}

_logger = None

pymelTypeNameToMayaTypeName = {}

_withParentMenuStack = []

qtBinding = 'pyside'

pySideAvailable = True

pyQtAvailable = False


