text:
from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_osgManipulator', [dirname(__file__)])
        except ImportError:
            import _osgManipulator
            return _osgManipulator
        if fp is not None:
            try:
                _mod = imp.load_module('_osgManipulator', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _osgManipulator = swig_import_helper()
    del swig_import_helper
else:
    import _osgManipulator
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x

class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _osgManipulator.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _osgManipulator.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _osgManipulator.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _osgManipulator.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _osgManipulator.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _osgManipulator.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _osgManipulator.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _osgManipulator.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _osgManipulator.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _osgManipulator.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _osgManipulator.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _osgManipulator.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _osgManipulator.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _osgManipulator.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _osgManipulator.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _osgManipulator.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _osgManipulator.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _osgManipulator.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import osg
OSGMANIPULATOR_EXPORT_ = _osgManipulator.OSGMANIPULATOR_EXPORT_
OSGMANIPULATOR_SELECTION = _osgManipulator.OSGMANIPULATOR_SELECTION
_OSG_ANTISQUISH_ = _osgManipulator._OSG_ANTISQUISH_
class AntiSquish(osg.MatrixTransform):
    """Proxy of C++ osgManipulator::AntiSquish class"""
    __swig_setmethods__ = {}
    for _s in [osg.MatrixTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AntiSquish, name, value)
    __swig_getmethods__ = {}
    for _s in [osg.MatrixTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AntiSquish, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::AntiSquish self) -> AntiSquish
        __init__(osgManipulator::AntiSquish self, Vec3d pivot) -> AntiSquish
        __init__(osgManipulator::AntiSquish self, Vec3d pivot, Vec3d position) -> AntiSquish
        __init__(osgManipulator::AntiSquish self, AntiSquish pat, CopyOp copyop=SHALLOW_COPY) -> AntiSquish
        __init__(osgManipulator::AntiSquish self, AntiSquish pat) -> AntiSquish
        """
        this = _osgManipulator.new_AntiSquish(*args)
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(AntiSquish self) -> Object"""
        return _osgManipulator.AntiSquish_cloneType(self)

    def clone(self, *args):
        """clone(AntiSquish self, CopyOp copyop) -> Object"""
        return _osgManipulator.AntiSquish_clone(self, *args)

    def isSameKindAs(self, *args):
        """isSameKindAs(AntiSquish self, Object obj) -> bool"""
        return _osgManipulator.AntiSquish_isSameKindAs(self, *args)

    def setPivot(self, *args):
        """setPivot(AntiSquish self, Vec3d pvt)"""
        return _osgManipulator.AntiSquish_setPivot(self, *args)

    def getPivot(self):
        """getPivot(AntiSquish self) -> Vec3d"""
        return _osgManipulator.AntiSquish_getPivot(self)

    def setPosition(self, *args):
        """setPosition(AntiSquish self, Vec3d pos)"""
        return _osgManipulator.AntiSquish_setPosition(self, *args)

    def getPosition(self):
        """getPosition(AntiSquish self) -> Vec3d"""
        return _osgManipulator.AntiSquish_getPosition(self)

    __swig_destroy__ = _osgManipulator.delete_AntiSquish
    __del__ = lambda self : None;
    def computeUnSquishedMatrix(self, *args):
        """computeUnSquishedMatrix(AntiSquish self, Matrixd arg2, bool & flag) -> Matrixd"""
        return _osgManipulator.AntiSquish_computeUnSquishedMatrix(self, *args)

AntiSquish_swigregister = _osgManipulator.AntiSquish_swigregister
AntiSquish_swigregister(AntiSquish)

OSGMANIPULATOR_COMMAND = _osgManipulator.OSGMANIPULATOR_COMMAND
class MotionCommand(osg.Referenced):
    """Proxy of C++ osgManipulator::MotionCommand class"""
    __swig_setmethods__ = {}
    for _s in [osg.Referenced]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MotionCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [osg.Referenced]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MotionCommand, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    NONE = _osgManipulator.MotionCommand_NONE
    START = _osgManipulator.MotionCommand_START
    MOVE = _osgManipulator.MotionCommand_MOVE
    FINISH = _osgManipulator.MotionCommand_FINISH
    def createCommandInverse(self):
        """createCommandInverse(MotionCommand self) -> MotionCommand"""
        return _osgManipulator.MotionCommand_createCommandInverse(self)

    def getMotionMatrix(self):
        """getMotionMatrix(MotionCommand self) -> Matrixd"""
        return _osgManipulator.MotionCommand_getMotionMatrix(self)

    def accept(self, *args):
        """
        accept(MotionCommand self, Constraint constraint)
        accept(MotionCommand self, DraggerCallback callback)
        """
        return _osgManipulator.MotionCommand_accept(self, *args)

    def setLocalToWorldAndWorldToLocal(self, *args):
        """setLocalToWorldAndWorldToLocal(MotionCommand self, Matrixd localToWorld, Matrixd worldToLocal)"""
        return _osgManipulator.MotionCommand_setLocalToWorldAndWorldToLocal(self, *args)

    def getLocalToWorld(self):
        """getLocalToWorld(MotionCommand self) -> Matrixd"""
        return _osgManipulator.MotionCommand_getLocalToWorld(self)

    def getWorldToLocal(self):
        """getWorldToLocal(MotionCommand self) -> Matrixd"""
        return _osgManipulator.MotionCommand_getWorldToLocal(self)

    def setStage(self, *args):
        """setStage(MotionCommand self, osgManipulator::MotionCommand::Stage const s)"""
        return _osgManipulator.MotionCommand_setStage(self, *args)

    def getStage(self):
        """getStage(MotionCommand self) -> osgManipulator::MotionCommand::Stage"""
        return _osgManipulator.MotionCommand_getStage(self)

MotionCommand_swigregister = _osgManipulator.MotionCommand_swigregister
MotionCommand_swigregister(MotionCommand)

class TranslateInLineCommand(MotionCommand):
    """Proxy of C++ osgManipulator::TranslateInLineCommand class"""
    __swig_setmethods__ = {}
    for _s in [MotionCommand]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TranslateInLineCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [MotionCommand]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TranslateInLineCommand, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::TranslateInLineCommand self) -> TranslateInLineCommand
        __init__(osgManipulator::TranslateInLineCommand self, osg::LineSegment::vec_type const & s, osg::LineSegment::vec_type const & e) -> TranslateInLineCommand
        """
        this = _osgManipulator.new_TranslateInLineCommand(*args)
        try: self.this.append(this)
        except: self.this = this
    def accept(self, *args):
        """
        accept(TranslateInLineCommand self, Constraint constraint)
        accept(TranslateInLineCommand self, DraggerCallback callback)
        """
        return _osgManipulator.TranslateInLineCommand_accept(self, *args)

    def createCommandInverse(self):
        """createCommandInverse(TranslateInLineCommand self) -> MotionCommand"""
        return _osgManipulator.TranslateInLineCommand_createCommandInverse(self)

    def setLine(self, *args):
        """setLine(TranslateInLineCommand self, osg::LineSegment::vec_type const & s, osg::LineSegment::vec_type const & e)"""
        return _osgManipulator.TranslateInLineCommand_setLine(self, *args)

    def getLineStart(self):
        """getLineStart(TranslateInLineCommand self) -> osg::LineSegment::vec_type const &"""
        return _osgManipulator.TranslateInLineCommand_getLineStart(self)

    def getLineEnd(self):
        """getLineEnd(TranslateInLineCommand self) -> osg::LineSegment::vec_type const &"""
        return _osgManipulator.TranslateInLineCommand_getLineEnd(self)

    def setTranslation(self, *args):
        """setTranslation(TranslateInLineCommand self, Vec3f t)"""
        return _osgManipulator.TranslateInLineCommand_setTranslation(self, *args)

    def getTranslation(self):
        """getTranslation(TranslateInLineCommand self) -> Vec3d"""
        return _osgManipulator.TranslateInLineCommand_getTranslation(self)

    def getMotionMatrix(self):
        """getMotionMatrix(TranslateInLineCommand self) -> Matrixd"""
        return _osgManipulator.TranslateInLineCommand_getMotionMatrix(self)

TranslateInLineCommand_swigregister = _osgManipulator.TranslateInLineCommand_swigregister
TranslateInLineCommand_swigregister(TranslateInLineCommand)

class TranslateInPlaneCommand(MotionCommand):
    """Proxy of C++ osgManipulator::TranslateInPlaneCommand class"""
    __swig_setmethods__ = {}
    for _s in [MotionCommand]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TranslateInPlaneCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [MotionCommand]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TranslateInPlaneCommand, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::TranslateInPlaneCommand self) -> TranslateInPlaneCommand
        __init__(osgManipulator::TranslateInPlaneCommand self, Plane plane) -> TranslateInPlaneCommand
        """
        this = _osgManipulator.new_TranslateInPlaneCommand(*args)
        try: self.this.append(this)
        except: self.this = this
    def accept(self, *args):
        """
        accept(TranslateInPlaneCommand self, Constraint constraint)
        accept(TranslateInPlaneCommand self, DraggerCallback callback)
        """
        return _osgManipulator.TranslateInPlaneCommand_accept(self, *args)

    def createCommandInverse(self):
        """createCommandInverse(TranslateInPlaneCommand self) -> MotionCommand"""
        return _osgManipulator.TranslateInPlaneCommand_createCommandInverse(self)

    def setPlane(self, *args):
        """setPlane(TranslateInPlaneCommand self, Plane plane)"""
        return _osgManipulator.TranslateInPlaneCommand_setPlane(self, *args)

    def getPlane(self):
        """getPlane(TranslateInPlaneCommand self) -> Plane"""
        return _osgManipulator.TranslateInPlaneCommand_getPlane(self)

    def setTranslation(self, *args):
        """setTranslation(TranslateInPlaneCommand self, Vec3d t)"""
        return _osgManipulator.TranslateInPlaneCommand_setTranslation(self, *args)

    def getTranslation(self):
        """getTranslation(TranslateInPlaneCommand self) -> Vec3d"""
        return _osgManipulator.TranslateInPlaneCommand_getTranslation(self)

    def setReferencePoint(self, *args):
        """setReferencePoint(TranslateInPlaneCommand self, Vec3d rp)"""
        return _osgManipulator.TranslateInPlaneCommand_setReferencePoint(self, *args)

    def getReferencePoint(self):
        """getReferencePoint(TranslateInPlaneCommand self) -> Vec3d"""
        return _osgManipulator.TranslateInPlaneCommand_getReferencePoint(self)

    def getMotionMatrix(self):
        """getMotionMatrix(TranslateInPlaneCommand self) -> Matrixd"""
        return _osgManipulator.TranslateInPlaneCommand_getMotionMatrix(self)

TranslateInPlaneCommand_swigregister = _osgManipulator.TranslateInPlaneCommand_swigregister
TranslateInPlaneCommand_swigregister(TranslateInPlaneCommand)

class Scale1DCommand(MotionCommand):
    """Proxy of C++ osgManipulator::Scale1DCommand class"""
    __swig_setmethods__ = {}
    for _s in [MotionCommand]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scale1DCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [MotionCommand]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Scale1DCommand, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::Scale1DCommand self) -> Scale1DCommand"""
        this = _osgManipulator.new_Scale1DCommand()
        try: self.this.append(this)
        except: self.this = this
    def accept(self, *args):
        """
        accept(Scale1DCommand self, Constraint constraint)
        accept(Scale1DCommand self, DraggerCallback callback)
        """
        return _osgManipulator.Scale1DCommand_accept(self, *args)

    def createCommandInverse(self):
        """createCommandInverse(Scale1DCommand self) -> MotionCommand"""
        return _osgManipulator.Scale1DCommand_createCommandInverse(self)

    def setScale(self, *args):
        """setScale(Scale1DCommand self, double s)"""
        return _osgManipulator.Scale1DCommand_setScale(self, *args)

    def getScale(self):
        """getScale(Scale1DCommand self) -> double"""
        return _osgManipulator.Scale1DCommand_getScale(self)

    def setScaleCenter(self, *args):
        """setScaleCenter(Scale1DCommand self, double center)"""
        return _osgManipulator.Scale1DCommand_setScaleCenter(self, *args)

    def getScaleCenter(self):
        """getScaleCenter(Scale1DCommand self) -> double"""
        return _osgManipulator.Scale1DCommand_getScaleCenter(self)

    def setReferencePoint(self, *args):
        """setReferencePoint(Scale1DCommand self, double rp)"""
        return _osgManipulator.Scale1DCommand_setReferencePoint(self, *args)

    def getReferencePoint(self):
        """getReferencePoint(Scale1DCommand self) -> double"""
        return _osgManipulator.Scale1DCommand_getReferencePoint(self)

    def setMinScale(self, *args):
        """setMinScale(Scale1DCommand self, double min)"""
        return _osgManipulator.Scale1DCommand_setMinScale(self, *args)

    def getMinScale(self):
        """getMinScale(Scale1DCommand self) -> double"""
        return _osgManipulator.Scale1DCommand_getMinScale(self)

    def getMotionMatrix(self):
        """getMotionMatrix(Scale1DCommand self) -> Matrixd"""
        return _osgManipulator.Scale1DCommand_getMotionMatrix(self)

Scale1DCommand_swigregister = _osgManipulator.Scale1DCommand_swigregister
Scale1DCommand_swigregister(Scale1DCommand)

class Scale2DCommand(MotionCommand):
    """Proxy of C++ osgManipulator::Scale2DCommand class"""
    __swig_setmethods__ = {}
    for _s in [MotionCommand]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scale2DCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [MotionCommand]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Scale2DCommand, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::Scale2DCommand self) -> Scale2DCommand"""
        this = _osgManipulator.new_Scale2DCommand()
        try: self.this.append(this)
        except: self.this = this
    def accept(self, *args):
        """
        accept(Scale2DCommand self, Constraint constraint)
        accept(Scale2DCommand self, DraggerCallback callback)
        """
        return _osgManipulator.Scale2DCommand_accept(self, *args)

    def createCommandInverse(self):
        """createCommandInverse(Scale2DCommand self) -> MotionCommand"""
        return _osgManipulator.Scale2DCommand_createCommandInverse(self)

    def setScale(self, *args):
        """setScale(Scale2DCommand self, Vec2d s)"""
        return _osgManipulator.Scale2DCommand_setScale(self, *args)

    def getScale(self):
        """getScale(Scale2DCommand self) -> Vec2d"""
        return _osgManipulator.Scale2DCommand_getScale(self)

    def setScaleCenter(self, *args):
        """setScaleCenter(Scale2DCommand self, Vec2d center)"""
        return _osgManipulator.Scale2DCommand_setScaleCenter(self, *args)

    def getScaleCenter(self):
        """getScaleCenter(Scale2DCommand self) -> Vec2d"""
        return _osgManipulator.Scale2DCommand_getScaleCenter(self)

    def setReferencePoint(self, *args):
        """setReferencePoint(Scale2DCommand self, Vec2d rp)"""
        return _osgManipulator.Scale2DCommand_setReferencePoint(self, *args)

    def getReferencePoint(self):
        """getReferencePoint(Scale2DCommand self) -> Vec2d"""
        return _osgManipulator.Scale2DCommand_getReferencePoint(self)

    def setMinScale(self, *args):
        """setMinScale(Scale2DCommand self, Vec2d min)"""
        return _osgManipulator.Scale2DCommand_setMinScale(self, *args)

    def getMinScale(self):
        """getMinScale(Scale2DCommand self) -> Vec2d"""
        return _osgManipulator.Scale2DCommand_getMinScale(self)

    def getMotionMatrix(self):
        """getMotionMatrix(Scale2DCommand self) -> Matrixd"""
        return _osgManipulator.Scale2DCommand_getMotionMatrix(self)

Scale2DCommand_swigregister = _osgManipulator.Scale2DCommand_swigregister
Scale2DCommand_swigregister(Scale2DCommand)

class ScaleUniformCommand(MotionCommand):
    """Proxy of C++ osgManipulator::ScaleUniformCommand class"""
    __swig_setmethods__ = {}
    for _s in [MotionCommand]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScaleUniformCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [MotionCommand]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScaleUniformCommand, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::ScaleUniformCommand self) -> ScaleUniformCommand"""
        this = _osgManipulator.new_ScaleUniformCommand()
        try: self.this.append(this)
        except: self.this = this
    def accept(self, *args):
        """
        accept(ScaleUniformCommand self, Constraint constraint)
        accept(ScaleUniformCommand self, DraggerCallback callback)
        """
        return _osgManipulator.ScaleUniformCommand_accept(self, *args)

    def createCommandInverse(self):
        """createCommandInverse(ScaleUniformCommand self) -> MotionCommand"""
        return _osgManipulator.ScaleUniformCommand_createCommandInverse(self)

    def setScale(self, *args):
        """setScale(ScaleUniformCommand self, double s)"""
        return _osgManipulator.ScaleUniformCommand_setScale(self, *args)

    def getScale(self):
        """getScale(ScaleUniformCommand self) -> double"""
        return _osgManipulator.ScaleUniformCommand_getScale(self)

    def setScaleCenter(self, *args):
        """setScaleCenter(ScaleUniformCommand self, Vec3d center)"""
        return _osgManipulator.ScaleUniformCommand_setScaleCenter(self, *args)

    def getScaleCenter(self):
        """getScaleCenter(ScaleUniformCommand self) -> Vec3d"""
        return _osgManipulator.ScaleUniformCommand_getScaleCenter(self)

    def getMotionMatrix(self):
        """getMotionMatrix(ScaleUniformCommand self) -> Matrixd"""
        return _osgManipulator.ScaleUniformCommand_getMotionMatrix(self)

ScaleUniformCommand_swigregister = _osgManipulator.ScaleUniformCommand_swigregister
ScaleUniformCommand_swigregister(ScaleUniformCommand)

class Rotate3DCommand(MotionCommand):
    """Proxy of C++ osgManipulator::Rotate3DCommand class"""
    __swig_setmethods__ = {}
    for _s in [MotionCommand]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rotate3DCommand, name, value)
    __swig_getmethods__ = {}
    for _s in [MotionCommand]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Rotate3DCommand, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::Rotate3DCommand self) -> Rotate3DCommand"""
        this = _osgManipulator.new_Rotate3DCommand()
        try: self.this.append(this)
        except: self.this = this
    def accept(self, *args):
        """
        accept(Rotate3DCommand self, Constraint constraint)
        accept(Rotate3DCommand self, DraggerCallback callback)
        """
        return _osgManipulator.Rotate3DCommand_accept(self, *args)

    def createCommandInverse(self):
        """createCommandInverse(Rotate3DCommand self) -> MotionCommand"""
        return _osgManipulator.Rotate3DCommand_createCommandInverse(self)

    def setRotation(self, *args):
        """setRotation(Rotate3DCommand self, Quat rotation)"""
        return _osgManipulator.Rotate3DCommand_setRotation(self, *args)

    def getRotation(self):
        """getRotation(Rotate3DCommand self) -> Quat"""
        return _osgManipulator.Rotate3DCommand_getRotation(self)

    def getMotionMatrix(self):
        """getMotionMatrix(Rotate3DCommand self) -> Matrixd"""
        return _osgManipulator.Rotate3DCommand_getMotionMatrix(self)

Rotate3DCommand_swigregister = _osgManipulator.Rotate3DCommand_swigregister
Rotate3DCommand_swigregister(Rotate3DCommand)

OSGMANIPULATOR_DRAGGER = _osgManipulator.OSGMANIPULATOR_DRAGGER

def computeNodePathToRoot(*args):
  """computeNodePathToRoot(Node node, vectorNode np)"""
  return _osgManipulator.computeNodePathToRoot(*args)
class DraggerTransformCallback(_object):
    """Proxy of C++ osgManipulator::DraggerTransformCallback class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DraggerTransformCallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DraggerTransformCallback, name)
    __repr__ = _swig_repr
    HANDLE_TRANSLATE_IN_LINE = _osgManipulator.DraggerTransformCallback_HANDLE_TRANSLATE_IN_LINE
    HANDLE_TRANSLATE_IN_PLANE = _osgManipulator.DraggerTransformCallback_HANDLE_TRANSLATE_IN_PLANE
    HANDLE_SCALED_1D = _osgManipulator.DraggerTransformCallback_HANDLE_SCALED_1D
    HANDLE_SCALED_2D = _osgManipulator.DraggerTransformCallback_HANDLE_SCALED_2D
    HANDLE_SCALED_UNIFORM = _osgManipulator.DraggerTransformCallback_HANDLE_SCALED_UNIFORM
    HANDLE_ROTATE_3D = _osgManipulator.DraggerTransformCallback_HANDLE_ROTATE_3D
    HANDLE_ALL = _osgManipulator.DraggerTransformCallback_HANDLE_ALL
    def __init__(self, *args):
        """
        __init__(osgManipulator::DraggerTransformCallback self, MatrixTransform transform, int handleCommandMask=HANDLE_ALL) -> DraggerTransformCallback
        __init__(osgManipulator::DraggerTransformCallback self, MatrixTransform transform) -> DraggerTransformCallback
        """
        this = _osgManipulator.new_DraggerTransformCallback(*args)
        try: self.this.append(this)
        except: self.this = this
    def receive(self, *args):
        """
        receive(DraggerTransformCallback self, MotionCommand arg2) -> bool
        receive(DraggerTransformCallback self, TranslateInLineCommand command) -> bool
        receive(DraggerTransformCallback self, TranslateInPlaneCommand command) -> bool
        receive(DraggerTransformCallback self, Scale1DCommand command) -> bool
        receive(DraggerTransformCallback self, Scale2DCommand command) -> bool
        receive(DraggerTransformCallback self, ScaleUniformCommand command) -> bool
        receive(DraggerTransformCallback self, Rotate3DCommand command) -> bool
        """
        return _osgManipulator.DraggerTransformCallback_receive(self, *args)

    def getTransform(self, *args):
        """
        getTransform(DraggerTransformCallback self) -> MatrixTransform
        getTransform(DraggerTransformCallback self) -> MatrixTransform
        """
        return _osgManipulator.DraggerTransformCallback_getTransform(self, *args)

    __swig_destroy__ = _osgManipulator.delete_DraggerTransformCallback
    __del__ = lambda self : None;
DraggerTransformCallback_swigregister = _osgManipulator.DraggerTransformCallback_swigregister
DraggerTransformCallback_swigregister(DraggerTransformCallback)

class PointerInfo(_object):
    """Proxy of C++ osgManipulator::PointerInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointerInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PointerInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::PointerInfo self) -> PointerInfo
        __init__(osgManipulator::PointerInfo self, PointerInfo rhs) -> PointerInfo
        """
        this = _osgManipulator.new_PointerInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    def reset(self):
        """reset(PointerInfo self)"""
        return _osgManipulator.PointerInfo_reset(self)

    def completed(self):
        """completed(PointerInfo self) -> bool"""
        return _osgManipulator.PointerInfo_completed(self)

    def next(self):
        """next(PointerInfo self)"""
        return _osgManipulator.PointerInfo_next(self)

    def getLocalIntersectPoint(self):
        """getLocalIntersectPoint(PointerInfo self) -> Vec3d"""
        return _osgManipulator.PointerInfo_getLocalIntersectPoint(self)

    def setNearFarPoints(self, *args):
        """setNearFarPoints(PointerInfo self, Vec3d nearPoint, Vec3d farPoint)"""
        return _osgManipulator.PointerInfo_setNearFarPoints(self, *args)

    def getEyeDir(self):
        """getEyeDir(PointerInfo self) -> Vec3d"""
        return _osgManipulator.PointerInfo_getEyeDir(self)

    def getNearFarPoints(self, *args):
        """getNearFarPoints(PointerInfo self, Vec3d nearPoint, Vec3d farPoint)"""
        return _osgManipulator.PointerInfo_getNearFarPoints(self, *args)

    def contains(self, *args):
        """contains(PointerInfo self, Node node) -> bool"""
        return _osgManipulator.PointerInfo_contains(self, *args)

    def setCamera(self, *args):
        """setCamera(PointerInfo self, Camera camera)"""
        return _osgManipulator.PointerInfo_setCamera(self, *args)

    def addIntersection(self, *args):
        """addIntersection(PointerInfo self, vectorNode nodePath, Vec3d intersectionPoint)"""
        return _osgManipulator.PointerInfo_addIntersection(self, *args)

    def setMousePosition(self, *args):
        """setMousePosition(PointerInfo self, float pixel_x, float pixel_y)"""
        return _osgManipulator.PointerInfo_setMousePosition(self, *args)

    __swig_setmethods__["_hitList"] = _osgManipulator.PointerInfo__hitList_set
    __swig_getmethods__["_hitList"] = _osgManipulator.PointerInfo__hitList_get
    if _newclass:_hitList = _swig_property(_osgManipulator.PointerInfo__hitList_get, _osgManipulator.PointerInfo__hitList_set)
    __swig_setmethods__["_hitIter"] = _osgManipulator.PointerInfo__hitIter_set
    __swig_getmethods__["_hitIter"] = _osgManipulator.PointerInfo__hitIter_get
    if _newclass:_hitIter = _swig_property(_osgManipulator.PointerInfo__hitIter_get, _osgManipulator.PointerInfo__hitIter_set)
    __swig_destroy__ = _osgManipulator.delete_PointerInfo
    __del__ = lambda self : None;
PointerInfo_swigregister = _osgManipulator.PointerInfo_swigregister
PointerInfo_swigregister(PointerInfo)

class Dragger(osg.MatrixTransform):
    """Proxy of C++ osgManipulator::Dragger class"""
    __swig_setmethods__ = {}
    for _s in [osg.MatrixTransform]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dragger, name, value)
    __swig_getmethods__ = {}
    for _s in [osg.MatrixTransform]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Dragger, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def cloneType(self):
        """cloneType(Dragger self) -> Object"""
        return _osgManipulator.Dragger_cloneType(self)

    def clone(self, *args):
        """clone(Dragger self, CopyOp copyop) -> Object"""
        return _osgManipulator.Dragger_clone(self, *args)

    def isSameKindAs(self, *args):
        """isSameKindAs(Dragger self, Object obj) -> bool"""
        return _osgManipulator.Dragger_isSameKindAs(self, *args)

    def className(self):
        """className(Dragger self) -> char const *"""
        return _osgManipulator.Dragger_className(self)

    def libraryName(self):
        """libraryName(Dragger self) -> char const *"""
        return _osgManipulator.Dragger_libraryName(self)

    def accept(self, *args):
        """accept(Dragger self, NodeVisitor nv)"""
        return _osgManipulator.Dragger_accept(self, *args)

    def setParentDragger(self, *args):
        """setParentDragger(Dragger self, Dragger parent)"""
        return _osgManipulator.Dragger_setParentDragger(self, *args)

    def getParentDragger(self, *args):
        """
        getParentDragger(Dragger self) -> Dragger
        getParentDragger(Dragger self) -> Dragger
        """
        return _osgManipulator.Dragger_getParentDragger(self, *args)

    def getComposite(self, *args):
        """
        getComposite(Dragger self) -> CompositeDragger
        getComposite(Dragger self) -> CompositeDragger
        """
        return _osgManipulator.Dragger_getComposite(self, *args)

    def setHandleEvents(self, *args):
        """setHandleEvents(Dragger self, bool flag)"""
        return _osgManipulator.Dragger_setHandleEvents(self, *args)

    def getHandleEvents(self):
        """getHandleEvents(Dragger self) -> bool"""
        return _osgManipulator.Dragger_getHandleEvents(self)

    def setActivationModKeyMask(self, *args):
        """setActivationModKeyMask(Dragger self, unsigned int mask)"""
        return _osgManipulator.Dragger_setActivationModKeyMask(self, *args)

    def getActivationModKeyMask(self):
        """getActivationModKeyMask(Dragger self) -> unsigned int"""
        return _osgManipulator.Dragger_getActivationModKeyMask(self)

    def setActivationMouseButtonMask(self, *args):
        """setActivationMouseButtonMask(Dragger self, unsigned int mask)"""
        return _osgManipulator.Dragger_setActivationMouseButtonMask(self, *args)

    def getActivationMouseButtonMask(self):
        """getActivationMouseButtonMask(Dragger self) -> unsigned int"""
        return _osgManipulator.Dragger_getActivationMouseButtonMask(self)

    def setActivationKeyEvent(self, *args):
        """setActivationKeyEvent(Dragger self, int key)"""
        return _osgManipulator.Dragger_setActivationKeyEvent(self, *args)

    def getActivationKeyEvent(self):
        """getActivationKeyEvent(Dragger self) -> int"""
        return _osgManipulator.Dragger_getActivationKeyEvent(self)

    def traverse(self, *args):
        """traverse(Dragger self, NodeVisitor nv)"""
        return _osgManipulator.Dragger_traverse(self, *args)

    def handle(self, *args):
        """
        handle(Dragger self, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & aa) -> bool
        handle(Dragger self, PointerInfo arg2, osgGA::GUIEventAdapter const & arg3, osgGA::GUIActionAdapter & arg4) -> bool
        """
        return _osgManipulator.Dragger_handle(self, *args)

    def addConstraint(self, *args):
        """addConstraint(Dragger self, Constraint constraint)"""
        return _osgManipulator.Dragger_addConstraint(self, *args)

    def removeConstraint(self, *args):
        """removeConstraint(Dragger self, Constraint constraint)"""
        return _osgManipulator.Dragger_removeConstraint(self, *args)

    def getConstraints(self, *args):
        """
        getConstraints(Dragger self) -> osgManipulator::Dragger::Constraints
        getConstraints(Dragger self) -> osgManipulator::Dragger::Constraints const &
        """
        return _osgManipulator.Dragger_getConstraints(self, *args)

    def addDraggerCallback(self, *args):
        """addDraggerCallback(Dragger self, DraggerCallback dc)"""
        return _osgManipulator.Dragger_addDraggerCallback(self, *args)

    def removeDraggerCallback(self, *args):
        """removeDraggerCallback(Dragger self, DraggerCallback dc)"""
        return _osgManipulator.Dragger_removeDraggerCallback(self, *args)

    def getDraggerCallbacks(self, *args):
        """
        getDraggerCallbacks(Dragger self) -> osgManipulator::Dragger::DraggerCallbacks
        getDraggerCallbacks(Dragger self) -> osgManipulator::Dragger::DraggerCallbacks const &
        """
        return _osgManipulator.Dragger_getDraggerCallbacks(self, *args)

    def addTransformUpdating(self, *args):
        """
        addTransformUpdating(Dragger self, MatrixTransform transform, int handleCommandMask=HANDLE_ALL)
        addTransformUpdating(Dragger self, MatrixTransform transform)
        """
        return _osgManipulator.Dragger_addTransformUpdating(self, *args)

    def removeTransformUpdating(self, *args):
        """removeTransformUpdating(Dragger self, MatrixTransform transform)"""
        return _osgManipulator.Dragger_removeTransformUpdating(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(Dragger self)"""
        return _osgManipulator.Dragger_setupDefaultGeometry(self)

    def receive(self, *args):
        """receive(Dragger self, MotionCommand command) -> bool"""
        return _osgManipulator.Dragger_receive(self, *args)

    def dispatch(self, *args):
        """dispatch(Dragger self, MotionCommand command)"""
        return _osgManipulator.Dragger_dispatch(self, *args)

    def setDraggerActive(self, *args):
        """setDraggerActive(Dragger self, bool active)"""
        return _osgManipulator.Dragger_setDraggerActive(self, *args)

    def getDraggerActive(self):
        """getDraggerActive(Dragger self) -> bool"""
        return _osgManipulator.Dragger_getDraggerActive(self)

    def setIntersectionMask(self, *args):
        """setIntersectionMask(Dragger self, osg::Node::NodeMask intersectionMask)"""
        return _osgManipulator.Dragger_setIntersectionMask(self, *args)

    def getIntersectionMask(self):
        """getIntersectionMask(Dragger self) -> osg::Node::NodeMask"""
        return _osgManipulator.Dragger_getIntersectionMask(self)

Dragger_swigregister = _osgManipulator.Dragger_swigregister
Dragger_swigregister(Dragger)

class CompositeDragger(Dragger):
    """Proxy of C++ osgManipulator::CompositeDragger class"""
    __swig_setmethods__ = {}
    for _s in [Dragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompositeDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [Dragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompositeDragger, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def cloneType(self):
        """cloneType(CompositeDragger self) -> Object"""
        return _osgManipulator.CompositeDragger_cloneType(self)

    def clone(self, *args):
        """clone(CompositeDragger self, CopyOp copyop) -> Object"""
        return _osgManipulator.CompositeDragger_clone(self, *args)

    def isSameKindAs(self, *args):
        """isSameKindAs(CompositeDragger self, Object obj) -> bool"""
        return _osgManipulator.CompositeDragger_isSameKindAs(self, *args)

    def className(self):
        """className(CompositeDragger self) -> char const *"""
        return _osgManipulator.CompositeDragger_className(self)

    def libraryName(self):
        """libraryName(CompositeDragger self) -> char const *"""
        return _osgManipulator.CompositeDragger_libraryName(self)

    def accept(self, *args):
        """accept(CompositeDragger self, NodeVisitor nv)"""
        return _osgManipulator.CompositeDragger_accept(self, *args)

    def getComposite(self, *args):
        """
        getComposite(CompositeDragger self) -> CompositeDragger
        getComposite(CompositeDragger self) -> CompositeDragger
        """
        return _osgManipulator.CompositeDragger_getComposite(self, *args)

    def setParentDragger(self, *args):
        """setParentDragger(CompositeDragger self, Dragger parent)"""
        return _osgManipulator.CompositeDragger_setParentDragger(self, *args)

    def handle(self, *args):
        """handle(CompositeDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & aa) -> bool"""
        return _osgManipulator.CompositeDragger_handle(self, *args)

    def addDragger(self, *args):
        """addDragger(CompositeDragger self, Dragger dragger) -> bool"""
        return _osgManipulator.CompositeDragger_addDragger(self, *args)

    def removeDragger(self, *args):
        """removeDragger(CompositeDragger self, Dragger dragger) -> bool"""
        return _osgManipulator.CompositeDragger_removeDragger(self, *args)

    def getNumDraggers(self):
        """getNumDraggers(CompositeDragger self) -> unsigned int"""
        return _osgManipulator.CompositeDragger_getNumDraggers(self)

    def getDragger(self, *args):
        """
        getDragger(CompositeDragger self, unsigned int i) -> Dragger
        getDragger(CompositeDragger self, unsigned int i) -> Dragger
        """
        return _osgManipulator.CompositeDragger_getDragger(self, *args)

    def containsDragger(self, *args):
        """containsDragger(CompositeDragger self, Dragger dragger) -> bool"""
        return _osgManipulator.CompositeDragger_containsDragger(self, *args)

    def findDragger(self, *args):
        """findDragger(CompositeDragger self, Dragger dragger) -> osgManipulator::CompositeDragger::DraggerList::iterator"""
        return _osgManipulator.CompositeDragger_findDragger(self, *args)

    def setIntersectionMask(self, *args):
        """setIntersectionMask(CompositeDragger self, osg::Node::NodeMask intersectionMask)"""
        return _osgManipulator.CompositeDragger_setIntersectionMask(self, *args)

CompositeDragger_swigregister = _osgManipulator.CompositeDragger_swigregister
CompositeDragger_swigregister(CompositeDragger)

def setDrawableToAlwaysCull(*args):
  """setDrawableToAlwaysCull(Drawable drawable)"""
  return _osgManipulator.setDrawableToAlwaysCull(*args)

def setMaterialColor(*args):
  """setMaterialColor(Vec4f color, Node node)"""
  return _osgManipulator.setMaterialColor(*args)
OSGMANIPULATOR_COMMANDMANAGER = _osgManipulator.OSGMANIPULATOR_COMMANDMANAGER
class CommandManager(osg.Referenced):
    """Proxy of C++ osgManipulator::CommandManager class"""
    __swig_setmethods__ = {}
    for _s in [osg.Referenced]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CommandManager, name, value)
    __swig_getmethods__ = {}
    for _s in [osg.Referenced]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CommandManager, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::CommandManager self) -> CommandManager"""
        this = _osgManipulator.new_CommandManager()
        try: self.this.append(this)
        except: self.this = this
    def connect(self, *args):
        """
        connect(CommandManager self, Dragger dragger, MatrixTransform selection) -> bool
        connect(CommandManager self, Dragger dragger, Constraint constraint) -> bool
        """
        return _osgManipulator.CommandManager_connect(self, *args)

    def disconnect(self, *args):
        """disconnect(CommandManager self, Dragger dragger) -> bool"""
        return _osgManipulator.CommandManager_disconnect(self, *args)

    def getConnectedSelections(self, *args):
        """getConnectedSelections(CommandManager self, Dragger dragger) -> osgManipulator::CommandManager::Selections"""
        return _osgManipulator.CommandManager_getConnectedSelections(self, *args)

CommandManager_swigregister = _osgManipulator.CommandManager_swigregister
CommandManager_swigregister(CommandManager)

OSGMANIPULATOR_CONSTRAINT = _osgManipulator.OSGMANIPULATOR_CONSTRAINT
class DraggerCallback(osg.Object):
    """Proxy of C++ osgManipulator::DraggerCallback class"""
    __swig_setmethods__ = {}
    for _s in [osg.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DraggerCallback, name, value)
    __swig_getmethods__ = {}
    for _s in [osg.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DraggerCallback, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::DraggerCallback self) -> DraggerCallback
        __init__(osgManipulator::DraggerCallback self, DraggerCallback arg2, CopyOp arg3=SHALLOW_COPY) -> DraggerCallback
        __init__(osgManipulator::DraggerCallback self, DraggerCallback arg2) -> DraggerCallback
        """
        this = _osgManipulator.new_DraggerCallback(*args)
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(DraggerCallback self) -> Object"""
        return _osgManipulator.DraggerCallback_cloneType(self)

    def clone(self, *args):
        """clone(DraggerCallback self, CopyOp copyop) -> Object"""
        return _osgManipulator.DraggerCallback_clone(self, *args)

    def isSameKindAs(self, *args):
        """isSameKindAs(DraggerCallback self, Object obj) -> bool"""
        return _osgManipulator.DraggerCallback_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(DraggerCallback self) -> char const *"""
        return _osgManipulator.DraggerCallback_libraryName(self)

    def className(self):
        """className(DraggerCallback self) -> char const *"""
        return _osgManipulator.DraggerCallback_className(self)

    def receive(self, *args):
        """
        receive(DraggerCallback self, MotionCommand arg2) -> bool
        receive(DraggerCallback self, TranslateInLineCommand command) -> bool
        receive(DraggerCallback self, TranslateInPlaneCommand command) -> bool
        receive(DraggerCallback self, Scale1DCommand command) -> bool
        receive(DraggerCallback self, Scale2DCommand command) -> bool
        receive(DraggerCallback self, ScaleUniformCommand command) -> bool
        receive(DraggerCallback self, Rotate3DCommand command) -> bool
        """
        return _osgManipulator.DraggerCallback_receive(self, *args)

    __swig_destroy__ = _osgManipulator.delete_DraggerCallback
    __del__ = lambda self : None;
DraggerCallback_swigregister = _osgManipulator.DraggerCallback_swigregister
DraggerCallback_swigregister(DraggerCallback)

class Constraint(osg.Referenced):
    """Proxy of C++ osgManipulator::Constraint class"""
    __swig_setmethods__ = {}
    for _s in [osg.Referenced]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Constraint, name, value)
    __swig_getmethods__ = {}
    for _s in [osg.Referenced]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Constraint, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def constrain(self, *args):
        """
        constrain(Constraint self, MotionCommand arg2) -> bool
        constrain(Constraint self, TranslateInLineCommand command) -> bool
        constrain(Constraint self, TranslateInPlaneCommand command) -> bool
        constrain(Constraint self, Scale1DCommand command) -> bool
        constrain(Constraint self, Scale2DCommand command) -> bool
        constrain(Constraint self, ScaleUniformCommand command) -> bool
        constrain(Constraint self, Rotate3DCommand command) -> bool
        """
        return _osgManipulator.Constraint_constrain(self, *args)

Constraint_swigregister = _osgManipulator.Constraint_swigregister
Constraint_swigregister(Constraint)

class GridConstraint(Constraint):
    """Proxy of C++ osgManipulator::GridConstraint class"""
    __swig_setmethods__ = {}
    for _s in [Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GridConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GridConstraint, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """__init__(osgManipulator::GridConstraint self, Node refNode, Vec3d origin, Vec3d spacing) -> GridConstraint"""
        this = _osgManipulator.new_GridConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def setOrigin(self, *args):
        """setOrigin(GridConstraint self, Vec3d origin)"""
        return _osgManipulator.GridConstraint_setOrigin(self, *args)

    def getOrigin(self):
        """getOrigin(GridConstraint self) -> Vec3d"""
        return _osgManipulator.GridConstraint_getOrigin(self)

    def setSpacing(self, *args):
        """setSpacing(GridConstraint self, Vec3d spacing)"""
        return _osgManipulator.GridConstraint_setSpacing(self, *args)

    def getSpacing(self):
        """getSpacing(GridConstraint self) -> Vec3d"""
        return _osgManipulator.GridConstraint_getSpacing(self)

    def constrain(self, *args):
        """
        constrain(GridConstraint self, TranslateInLineCommand command) -> bool
        constrain(GridConstraint self, TranslateInPlaneCommand command) -> bool
        constrain(GridConstraint self, Scale1DCommand command) -> bool
        constrain(GridConstraint self, Scale2DCommand command) -> bool
        constrain(GridConstraint self, ScaleUniformCommand command) -> bool
        """
        return _osgManipulator.GridConstraint_constrain(self, *args)

GridConstraint_swigregister = _osgManipulator.GridConstraint_swigregister
GridConstraint_swigregister(GridConstraint)

OSGMANIPULATOR_PROJECTOR = _osgManipulator.OSGMANIPULATOR_PROJECTOR
class Projector(osg.Referenced):
    """Proxy of C++ osgManipulator::Projector class"""
    __swig_setmethods__ = {}
    for _s in [osg.Referenced]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Projector, name, value)
    __swig_getmethods__ = {}
    for _s in [osg.Referenced]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Projector, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def project(self, *args):
        """project(Projector self, PointerInfo pi, Vec3d projectedPoint) -> bool"""
        return _osgManipulator.Projector_project(self, *args)

    def setLocalToWorld(self, *args):
        """setLocalToWorld(Projector self, Matrixd localToWorld)"""
        return _osgManipulator.Projector_setLocalToWorld(self, *args)

    def getLocalToWorld(self):
        """getLocalToWorld(Projector self) -> Matrixd"""
        return _osgManipulator.Projector_getLocalToWorld(self)

    def getWorldToLocal(self):
        """getWorldToLocal(Projector self) -> Matrixd"""
        return _osgManipulator.Projector_getWorldToLocal(self)

Projector_swigregister = _osgManipulator.Projector_swigregister
Projector_swigregister(Projector)

class LineProjector(Projector):
    """Proxy of C++ osgManipulator::LineProjector class"""
    __swig_setmethods__ = {}
    for _s in [Projector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LineProjector, name, value)
    __swig_getmethods__ = {}
    for _s in [Projector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LineProjector, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::LineProjector self) -> LineProjector
        __init__(osgManipulator::LineProjector self, osg::LineSegment::vec_type const & s, osg::LineSegment::vec_type const & e) -> LineProjector
        """
        this = _osgManipulator.new_LineProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def setLine(self, *args):
        """setLine(LineProjector self, osg::LineSegment::vec_type const & s, osg::LineSegment::vec_type const & e)"""
        return _osgManipulator.LineProjector_setLine(self, *args)

    def getLineStart(self, *args):
        """
        getLineStart(LineProjector self) -> osg::LineSegment::vec_type const
        getLineStart(LineProjector self) -> osg::LineSegment::vec_type &
        """
        return _osgManipulator.LineProjector_getLineStart(self, *args)

    def getLineEnd(self, *args):
        """
        getLineEnd(LineProjector self) -> osg::LineSegment::vec_type const
        getLineEnd(LineProjector self) -> osg::LineSegment::vec_type &
        """
        return _osgManipulator.LineProjector_getLineEnd(self, *args)

    def project(self, *args):
        """project(LineProjector self, PointerInfo pi, Vec3d projectedPoint) -> bool"""
        return _osgManipulator.LineProjector_project(self, *args)

LineProjector_swigregister = _osgManipulator.LineProjector_swigregister
LineProjector_swigregister(LineProjector)

class PlaneProjector(Projector):
    """Proxy of C++ osgManipulator::PlaneProjector class"""
    __swig_setmethods__ = {}
    for _s in [Projector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlaneProjector, name, value)
    __swig_getmethods__ = {}
    for _s in [Projector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PlaneProjector, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::PlaneProjector self) -> PlaneProjector
        __init__(osgManipulator::PlaneProjector self, Plane plane) -> PlaneProjector
        """
        this = _osgManipulator.new_PlaneProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def setPlane(self, *args):
        """setPlane(PlaneProjector self, Plane plane)"""
        return _osgManipulator.PlaneProjector_setPlane(self, *args)

    def getPlane(self):
        """getPlane(PlaneProjector self) -> Plane"""
        return _osgManipulator.PlaneProjector_getPlane(self)

    def project(self, *args):
        """project(PlaneProjector self, PointerInfo pi, Vec3d projectedPoint) -> bool"""
        return _osgManipulator.PlaneProjector_project(self, *args)

PlaneProjector_swigregister = _osgManipulator.PlaneProjector_swigregister
PlaneProjector_swigregister(PlaneProjector)

class SphereProjector(Projector):
    """Proxy of C++ osgManipulator::SphereProjector class"""
    __swig_setmethods__ = {}
    for _s in [Projector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SphereProjector, name, value)
    __swig_getmethods__ = {}
    for _s in [Projector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SphereProjector, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::SphereProjector self) -> SphereProjector
        __init__(osgManipulator::SphereProjector self, Sphere sphere) -> SphereProjector
        """
        this = _osgManipulator.new_SphereProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def setSphere(self, *args):
        """setSphere(SphereProjector self, Sphere sphere)"""
        return _osgManipulator.SphereProjector_setSphere(self, *args)

    def getSphere(self):
        """getSphere(SphereProjector self) -> Sphere"""
        return _osgManipulator.SphereProjector_getSphere(self)

    def project(self, *args):
        """project(SphereProjector self, PointerInfo pi, Vec3d projectedPoint) -> bool"""
        return _osgManipulator.SphereProjector_project(self, *args)

    def isPointInFront(self, *args):
        """isPointInFront(SphereProjector self, PointerInfo pi, Matrixd localToWorld) -> bool"""
        return _osgManipulator.SphereProjector_isPointInFront(self, *args)

    def setFront(self, *args):
        """setFront(SphereProjector self, bool front)"""
        return _osgManipulator.SphereProjector_setFront(self, *args)

SphereProjector_swigregister = _osgManipulator.SphereProjector_swigregister
SphereProjector_swigregister(SphereProjector)

class SpherePlaneProjector(SphereProjector):
    """Proxy of C++ osgManipulator::SpherePlaneProjector class"""
    __swig_setmethods__ = {}
    for _s in [SphereProjector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpherePlaneProjector, name, value)
    __swig_getmethods__ = {}
    for _s in [SphereProjector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpherePlaneProjector, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::SpherePlaneProjector self) -> SpherePlaneProjector
        __init__(osgManipulator::SpherePlaneProjector self, Sphere sphere) -> SpherePlaneProjector
        """
        this = _osgManipulator.new_SpherePlaneProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def project(self, *args):
        """project(SpherePlaneProjector self, PointerInfo pi, Vec3d projectedPoint) -> bool"""
        return _osgManipulator.SpherePlaneProjector_project(self, *args)

    def isProjectionOnSphere(self):
        """isProjectionOnSphere(SpherePlaneProjector self) -> bool"""
        return _osgManipulator.SpherePlaneProjector_isProjectionOnSphere(self)

    def getRotation(self, *args):
        """
        getRotation(SpherePlaneProjector self, Vec3d p1, bool p1OnSphere, Vec3d p2, bool p2OnSphere, float radialFactor=0.0) -> Quat
        getRotation(SpherePlaneProjector self, Vec3d p1, bool p1OnSphere, Vec3d p2, bool p2OnSphere) -> Quat
        """
        return _osgManipulator.SpherePlaneProjector_getRotation(self, *args)

SpherePlaneProjector_swigregister = _osgManipulator.SpherePlaneProjector_swigregister
SpherePlaneProjector_swigregister(SpherePlaneProjector)

class CylinderProjector(Projector):
    """Proxy of C++ osgManipulator::CylinderProjector class"""
    __swig_setmethods__ = {}
    for _s in [Projector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CylinderProjector, name, value)
    __swig_getmethods__ = {}
    for _s in [Projector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CylinderProjector, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::CylinderProjector self) -> CylinderProjector
        __init__(osgManipulator::CylinderProjector self, Cylinder cylinder) -> CylinderProjector
        """
        this = _osgManipulator.new_CylinderProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def setCylinder(self, *args):
        """setCylinder(CylinderProjector self, Cylinder cylinder)"""
        return _osgManipulator.CylinderProjector_setCylinder(self, *args)

    def getCylinder(self):
        """getCylinder(CylinderProjector self) -> Cylinder"""
        return _osgManipulator.CylinderProjector_getCylinder(self)

    def project(self, *args):
        """project(CylinderProjector self, PointerInfo pi, Vec3d projectedPoint) -> bool"""
        return _osgManipulator.CylinderProjector_project(self, *args)

    def isPointInFront(self, *args):
        """isPointInFront(CylinderProjector self, PointerInfo pi, Matrixd localToWorld) -> bool"""
        return _osgManipulator.CylinderProjector_isPointInFront(self, *args)

    def setFront(self, *args):
        """setFront(CylinderProjector self, bool front)"""
        return _osgManipulator.CylinderProjector_setFront(self, *args)

CylinderProjector_swigregister = _osgManipulator.CylinderProjector_swigregister
CylinderProjector_swigregister(CylinderProjector)

class CylinderPlaneProjector(CylinderProjector):
    """Proxy of C++ osgManipulator::CylinderPlaneProjector class"""
    __swig_setmethods__ = {}
    for _s in [CylinderProjector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CylinderPlaneProjector, name, value)
    __swig_getmethods__ = {}
    for _s in [CylinderProjector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CylinderPlaneProjector, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::CylinderPlaneProjector self) -> CylinderPlaneProjector
        __init__(osgManipulator::CylinderPlaneProjector self, Cylinder cylinder) -> CylinderPlaneProjector
        """
        this = _osgManipulator.new_CylinderPlaneProjector(*args)
        try: self.this.append(this)
        except: self.this = this
    def project(self, *args):
        """project(CylinderPlaneProjector self, PointerInfo pi, Vec3d projectedPoint) -> bool"""
        return _osgManipulator.CylinderPlaneProjector_project(self, *args)

    def getRotation(self, *args):
        """getRotation(CylinderPlaneProjector self, Vec3d p1, Vec3d p2) -> Quat"""
        return _osgManipulator.CylinderPlaneProjector_getRotation(self, *args)

CylinderPlaneProjector_swigregister = _osgManipulator.CylinderPlaneProjector_swigregister
CylinderPlaneProjector_swigregister(CylinderPlaneProjector)

OSGMANIPULATOR_ROTATECYLINDERDRAGGER = _osgManipulator.OSGMANIPULATOR_ROTATECYLINDERDRAGGER
class RotateCylinderDragger(Dragger):
    """Proxy of C++ osgManipulator::RotateCylinderDragger class"""
    __swig_setmethods__ = {}
    for _s in [Dragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RotateCylinderDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [Dragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RotateCylinderDragger, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::RotateCylinderDragger self) -> RotateCylinderDragger"""
        this = _osgManipulator.new_RotateCylinderDragger()
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(RotateCylinderDragger self) -> Object"""
        return _osgManipulator.RotateCylinderDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(RotateCylinderDragger self, Object obj) -> bool"""
        return _osgManipulator.RotateCylinderDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(RotateCylinderDragger self) -> char const *"""
        return _osgManipulator.RotateCylinderDragger_libraryName(self)

    def className(self):
        """className(RotateCylinderDragger self) -> char const *"""
        return _osgManipulator.RotateCylinderDragger_className(self)

    def handle(self, *args):
        """handle(RotateCylinderDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.RotateCylinderDragger_handle(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(RotateCylinderDragger self)"""
        return _osgManipulator.RotateCylinderDragger_setupDefaultGeometry(self)

    def setColor(self, *args):
        """setColor(RotateCylinderDragger self, Vec4f color)"""
        return _osgManipulator.RotateCylinderDragger_setColor(self, *args)

    def getColor(self):
        """getColor(RotateCylinderDragger self) -> Vec4f"""
        return _osgManipulator.RotateCylinderDragger_getColor(self)

    def setPickColor(self, *args):
        """setPickColor(RotateCylinderDragger self, Vec4f color)"""
        return _osgManipulator.RotateCylinderDragger_setPickColor(self, *args)

    def getPickColor(self):
        """getPickColor(RotateCylinderDragger self) -> Vec4f"""
        return _osgManipulator.RotateCylinderDragger_getPickColor(self)

RotateCylinderDragger_swigregister = _osgManipulator.RotateCylinderDragger_swigregister
RotateCylinderDragger_swigregister(RotateCylinderDragger)

OSGMANIPULATOR_ROTATESPHEREDRAGGER = _osgManipulator.OSGMANIPULATOR_ROTATESPHEREDRAGGER
class RotateSphereDragger(Dragger):
    """Proxy of C++ osgManipulator::RotateSphereDragger class"""
    __swig_setmethods__ = {}
    for _s in [Dragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RotateSphereDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [Dragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RotateSphereDragger, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::RotateSphereDragger self) -> RotateSphereDragger"""
        this = _osgManipulator.new_RotateSphereDragger()
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(RotateSphereDragger self) -> Object"""
        return _osgManipulator.RotateSphereDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(RotateSphereDragger self, Object obj) -> bool"""
        return _osgManipulator.RotateSphereDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(RotateSphereDragger self) -> char const *"""
        return _osgManipulator.RotateSphereDragger_libraryName(self)

    def className(self):
        """className(RotateSphereDragger self) -> char const *"""
        return _osgManipulator.RotateSphereDragger_className(self)

    def handle(self, *args):
        """handle(RotateSphereDragger self, PointerInfo arg2, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.RotateSphereDragger_handle(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(RotateSphereDragger self)"""
        return _osgManipulator.RotateSphereDragger_setupDefaultGeometry(self)

    def setColor(self, *args):
        """setColor(RotateSphereDragger self, Vec4f color)"""
        return _osgManipulator.RotateSphereDragger_setColor(self, *args)

    def getColor(self):
        """getColor(RotateSphereDragger self) -> Vec4f"""
        return _osgManipulator.RotateSphereDragger_getColor(self)

    def setPickColor(self, *args):
        """setPickColor(RotateSphereDragger self, Vec4f color)"""
        return _osgManipulator.RotateSphereDragger_setPickColor(self, *args)

    def getPickColor(self):
        """getPickColor(RotateSphereDragger self) -> Vec4f"""
        return _osgManipulator.RotateSphereDragger_getPickColor(self)

RotateSphereDragger_swigregister = _osgManipulator.RotateSphereDragger_swigregister
RotateSphereDragger_swigregister(RotateSphereDragger)

OSGMANIPULATOR_SCALE1DDRAGGER = _osgManipulator.OSGMANIPULATOR_SCALE1DDRAGGER
class Scale1DDragger(Dragger):
    """Proxy of C++ osgManipulator::Scale1DDragger class"""
    __swig_setmethods__ = {}
    for _s in [Dragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scale1DDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [Dragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Scale1DDragger, name)
    __repr__ = _swig_repr
    SCALE_WITH_ORIGIN_AS_PIVOT = _osgManipulator.Scale1DDragger_SCALE_WITH_ORIGIN_AS_PIVOT
    SCALE_WITH_OPPOSITE_HANDLE_AS_PIVOT = _osgManipulator.Scale1DDragger_SCALE_WITH_OPPOSITE_HANDLE_AS_PIVOT
    def __init__(self, *args):
        """
        __init__(osgManipulator::Scale1DDragger self, osgManipulator::Scale1DDragger::ScaleMode scaleMode=SCALE_WITH_ORIGIN_AS_PIVOT) -> Scale1DDragger
        __init__(osgManipulator::Scale1DDragger self) -> Scale1DDragger
        """
        this = _osgManipulator.new_Scale1DDragger(*args)
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(Scale1DDragger self) -> Object"""
        return _osgManipulator.Scale1DDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(Scale1DDragger self, Object obj) -> bool"""
        return _osgManipulator.Scale1DDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(Scale1DDragger self) -> char const *"""
        return _osgManipulator.Scale1DDragger_libraryName(self)

    def className(self):
        """className(Scale1DDragger self) -> char const *"""
        return _osgManipulator.Scale1DDragger_className(self)

    def handle(self, *args):
        """handle(Scale1DDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.Scale1DDragger_handle(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(Scale1DDragger self)"""
        return _osgManipulator.Scale1DDragger_setupDefaultGeometry(self)

    def setMinScale(self, *args):
        """setMinScale(Scale1DDragger self, double min)"""
        return _osgManipulator.Scale1DDragger_setMinScale(self, *args)

    def getMinScale(self):
        """getMinScale(Scale1DDragger self) -> double"""
        return _osgManipulator.Scale1DDragger_getMinScale(self)

    def setColor(self, *args):
        """setColor(Scale1DDragger self, Vec4f color)"""
        return _osgManipulator.Scale1DDragger_setColor(self, *args)

    def getColor(self):
        """getColor(Scale1DDragger self) -> Vec4f"""
        return _osgManipulator.Scale1DDragger_getColor(self)

    def setPickColor(self, *args):
        """setPickColor(Scale1DDragger self, Vec4f color)"""
        return _osgManipulator.Scale1DDragger_setPickColor(self, *args)

    def getPickColor(self):
        """getPickColor(Scale1DDragger self) -> Vec4f"""
        return _osgManipulator.Scale1DDragger_getPickColor(self)

    def setLeftHandleNode(self, *args):
        """setLeftHandleNode(Scale1DDragger self, Node node)"""
        return _osgManipulator.Scale1DDragger_setLeftHandleNode(self, *args)

    def setRightHandleNode(self, *args):
        """setRightHandleNode(Scale1DDragger self, Node node)"""
        return _osgManipulator.Scale1DDragger_setRightHandleNode(self, *args)

    def getLeftHandleNode(self, *args):
        """
        getLeftHandleNode(Scale1DDragger self) -> Node
        getLeftHandleNode(Scale1DDragger self) -> Node
        """
        return _osgManipulator.Scale1DDragger_getLeftHandleNode(self, *args)

    def getRightHandleNode(self, *args):
        """
        getRightHandleNode(Scale1DDragger self) -> Node
        getRightHandleNode(Scale1DDragger self) -> Node
        """
        return _osgManipulator.Scale1DDragger_getRightHandleNode(self, *args)

    def setLeftHandlePosition(self, *args):
        """setLeftHandlePosition(Scale1DDragger self, double pos)"""
        return _osgManipulator.Scale1DDragger_setLeftHandlePosition(self, *args)

    def getLeftHandlePosition(self):
        """getLeftHandlePosition(Scale1DDragger self) -> double"""
        return _osgManipulator.Scale1DDragger_getLeftHandlePosition(self)

    def setRightHandlePosition(self, *args):
        """setRightHandlePosition(Scale1DDragger self, double pos)"""
        return _osgManipulator.Scale1DDragger_setRightHandlePosition(self, *args)

    def getRightHandlePosition(self):
        """getRightHandlePosition(Scale1DDragger self) -> double"""
        return _osgManipulator.Scale1DDragger_getRightHandlePosition(self)

Scale1DDragger_swigregister = _osgManipulator.Scale1DDragger_swigregister
Scale1DDragger_swigregister(Scale1DDragger)

OSGMANIPULATOR_SCALE2DDRAGGER = _osgManipulator.OSGMANIPULATOR_SCALE2DDRAGGER
class Scale2DDragger(Dragger):
    """Proxy of C++ osgManipulator::Scale2DDragger class"""
    __swig_setmethods__ = {}
    for _s in [Dragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scale2DDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [Dragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Scale2DDragger, name)
    __repr__ = _swig_repr
    SCALE_WITH_ORIGIN_AS_PIVOT = _osgManipulator.Scale2DDragger_SCALE_WITH_ORIGIN_AS_PIVOT
    SCALE_WITH_OPPOSITE_HANDLE_AS_PIVOT = _osgManipulator.Scale2DDragger_SCALE_WITH_OPPOSITE_HANDLE_AS_PIVOT
    def __init__(self, *args):
        """
        __init__(osgManipulator::Scale2DDragger self, osgManipulator::Scale2DDragger::ScaleMode scaleMode=SCALE_WITH_ORIGIN_AS_PIVOT) -> Scale2DDragger
        __init__(osgManipulator::Scale2DDragger self) -> Scale2DDragger
        """
        this = _osgManipulator.new_Scale2DDragger(*args)
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(Scale2DDragger self) -> Object"""
        return _osgManipulator.Scale2DDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(Scale2DDragger self, Object obj) -> bool"""
        return _osgManipulator.Scale2DDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(Scale2DDragger self) -> char const *"""
        return _osgManipulator.Scale2DDragger_libraryName(self)

    def className(self):
        """className(Scale2DDragger self) -> char const *"""
        return _osgManipulator.Scale2DDragger_className(self)

    def handle(self, *args):
        """handle(Scale2DDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.Scale2DDragger_handle(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(Scale2DDragger self)"""
        return _osgManipulator.Scale2DDragger_setupDefaultGeometry(self)

    def setMinScale(self, *args):
        """setMinScale(Scale2DDragger self, Vec2d min)"""
        return _osgManipulator.Scale2DDragger_setMinScale(self, *args)

    def getMinScale(self):
        """getMinScale(Scale2DDragger self) -> Vec2d"""
        return _osgManipulator.Scale2DDragger_getMinScale(self)

    def setColor(self, *args):
        """setColor(Scale2DDragger self, Vec4f color)"""
        return _osgManipulator.Scale2DDragger_setColor(self, *args)

    def getColor(self):
        """getColor(Scale2DDragger self) -> Vec4f"""
        return _osgManipulator.Scale2DDragger_getColor(self)

    def setPickColor(self, *args):
        """setPickColor(Scale2DDragger self, Vec4f color)"""
        return _osgManipulator.Scale2DDragger_setPickColor(self, *args)

    def getPickColor(self):
        """getPickColor(Scale2DDragger self) -> Vec4f"""
        return _osgManipulator.Scale2DDragger_getPickColor(self)

    def setTopLeftHandleNode(self, *args):
        """setTopLeftHandleNode(Scale2DDragger self, Node node)"""
        return _osgManipulator.Scale2DDragger_setTopLeftHandleNode(self, *args)

    def getTopLeftHandleNode(self, *args):
        """
        getTopLeftHandleNode(Scale2DDragger self) -> Node
        getTopLeftHandleNode(Scale2DDragger self) -> Node
        """
        return _osgManipulator.Scale2DDragger_getTopLeftHandleNode(self, *args)

    def setBottomLeftHandleNode(self, *args):
        """setBottomLeftHandleNode(Scale2DDragger self, Node node)"""
        return _osgManipulator.Scale2DDragger_setBottomLeftHandleNode(self, *args)

    def getBottomLeftHandleNode(self, *args):
        """
        getBottomLeftHandleNode(Scale2DDragger self) -> Node
        getBottomLeftHandleNode(Scale2DDragger self) -> Node
        """
        return _osgManipulator.Scale2DDragger_getBottomLeftHandleNode(self, *args)

    def setTopRightHandleNode(self, *args):
        """setTopRightHandleNode(Scale2DDragger self, Node node)"""
        return _osgManipulator.Scale2DDragger_setTopRightHandleNode(self, *args)

    def getTopRightHandleNode(self, *args):
        """
        getTopRightHandleNode(Scale2DDragger self) -> Node
        getTopRightHandleNode(Scale2DDragger self) -> Node
        """
        return _osgManipulator.Scale2DDragger_getTopRightHandleNode(self, *args)

    def setBottomRightHandleNode(self, *args):
        """setBottomRightHandleNode(Scale2DDragger self, Node node)"""
        return _osgManipulator.Scale2DDragger_setBottomRightHandleNode(self, *args)

    def getBottomRightHandleNode(self, *args):
        """
        getBottomRightHandleNode(Scale2DDragger self) -> Node
        getBottomRightHandleNode(Scale2DDragger self) -> Node
        """
        return _osgManipulator.Scale2DDragger_getBottomRightHandleNode(self, *args)

    def setTopLeftHandlePosition(self, *args):
        """setTopLeftHandlePosition(Scale2DDragger self, Vec2d pos)"""
        return _osgManipulator.Scale2DDragger_setTopLeftHandlePosition(self, *args)

    def getTopLeftHandlePosition(self):
        """getTopLeftHandlePosition(Scale2DDragger self) -> Vec2d"""
        return _osgManipulator.Scale2DDragger_getTopLeftHandlePosition(self)

    def setBottomLeftHandlePosition(self, *args):
        """setBottomLeftHandlePosition(Scale2DDragger self, Vec2d pos)"""
        return _osgManipulator.Scale2DDragger_setBottomLeftHandlePosition(self, *args)

    def getBottomLeftHandlePosition(self):
        """getBottomLeftHandlePosition(Scale2DDragger self) -> Vec2d"""
        return _osgManipulator.Scale2DDragger_getBottomLeftHandlePosition(self)

    def setTopRightHandlePosition(self, *args):
        """setTopRightHandlePosition(Scale2DDragger self, Vec2d pos)"""
        return _osgManipulator.Scale2DDragger_setTopRightHandlePosition(self, *args)

    def getTopRightHandlePosition(self):
        """getTopRightHandlePosition(Scale2DDragger self) -> Vec2d"""
        return _osgManipulator.Scale2DDragger_getTopRightHandlePosition(self)

    def setBottomRightHandlePosition(self, *args):
        """setBottomRightHandlePosition(Scale2DDragger self, Vec2d pos)"""
        return _osgManipulator.Scale2DDragger_setBottomRightHandlePosition(self, *args)

    def getBottomRightHandlePosition(self):
        """getBottomRightHandlePosition(Scale2DDragger self) -> Vec2d"""
        return _osgManipulator.Scale2DDragger_getBottomRightHandlePosition(self)

Scale2DDragger_swigregister = _osgManipulator.Scale2DDragger_swigregister
Scale2DDragger_swigregister(Scale2DDragger)

OSGMANIPULATOR_SCALEAXISDRAGGER = _osgManipulator.OSGMANIPULATOR_SCALEAXISDRAGGER
class ScaleAxisDragger(CompositeDragger):
    """Proxy of C++ osgManipulator::ScaleAxisDragger class"""
    __swig_setmethods__ = {}
    for _s in [CompositeDragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScaleAxisDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [CompositeDragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScaleAxisDragger, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::ScaleAxisDragger self) -> ScaleAxisDragger"""
        this = _osgManipulator.new_ScaleAxisDragger()
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(ScaleAxisDragger self) -> Object"""
        return _osgManipulator.ScaleAxisDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(ScaleAxisDragger self, Object obj) -> bool"""
        return _osgManipulator.ScaleAxisDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(ScaleAxisDragger self) -> char const *"""
        return _osgManipulator.ScaleAxisDragger_libraryName(self)

    def className(self):
        """className(ScaleAxisDragger self) -> char const *"""
        return _osgManipulator.ScaleAxisDragger_className(self)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(ScaleAxisDragger self)"""
        return _osgManipulator.ScaleAxisDragger_setupDefaultGeometry(self)

ScaleAxisDragger_swigregister = _osgManipulator.ScaleAxisDragger_swigregister
ScaleAxisDragger_swigregister(ScaleAxisDragger)

OSGMANIPULATOR_TABBOXDRAGGER = _osgManipulator.OSGMANIPULATOR_TABBOXDRAGGER
class TabBoxDragger(CompositeDragger):
    """Proxy of C++ osgManipulator::TabBoxDragger class"""
    __swig_setmethods__ = {}
    for _s in [CompositeDragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TabBoxDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [CompositeDragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TabBoxDragger, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::TabBoxDragger self) -> TabBoxDragger"""
        this = _osgManipulator.new_TabBoxDragger()
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(TabBoxDragger self) -> Object"""
        return _osgManipulator.TabBoxDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(TabBoxDragger self, Object obj) -> bool"""
        return _osgManipulator.TabBoxDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(TabBoxDragger self) -> char const *"""
        return _osgManipulator.TabBoxDragger_libraryName(self)

    def className(self):
        """className(TabBoxDragger self) -> char const *"""
        return _osgManipulator.TabBoxDragger_className(self)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(TabBoxDragger self)"""
        return _osgManipulator.TabBoxDragger_setupDefaultGeometry(self)

    def setPlaneColor(self, *args):
        """setPlaneColor(TabBoxDragger self, Vec4f color)"""
        return _osgManipulator.TabBoxDragger_setPlaneColor(self, *args)

TabBoxDragger_swigregister = _osgManipulator.TabBoxDragger_swigregister
TabBoxDragger_swigregister(TabBoxDragger)

OSGMANIPULATOR_TABPLANEDRAGGER = _osgManipulator.OSGMANIPULATOR_TABPLANEDRAGGER
class TabPlaneDragger(CompositeDragger):
    """Proxy of C++ osgManipulator::TabPlaneDragger class"""
    __swig_setmethods__ = {}
    for _s in [CompositeDragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TabPlaneDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [CompositeDragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TabPlaneDragger, name)
    __repr__ = _swig_repr
    def __init__(self, handleScaleFactor=20.0):
        """
        __init__(osgManipulator::TabPlaneDragger self, float handleScaleFactor=20.0) -> TabPlaneDragger
        __init__(osgManipulator::TabPlaneDragger self) -> TabPlaneDragger
        """
        this = _osgManipulator.new_TabPlaneDragger(handleScaleFactor)
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(TabPlaneDragger self) -> Object"""
        return _osgManipulator.TabPlaneDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(TabPlaneDragger self, Object obj) -> bool"""
        return _osgManipulator.TabPlaneDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(TabPlaneDragger self) -> char const *"""
        return _osgManipulator.TabPlaneDragger_libraryName(self)

    def className(self):
        """className(TabPlaneDragger self) -> char const *"""
        return _osgManipulator.TabPlaneDragger_className(self)

    def handle(self, *args):
        """handle(TabPlaneDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.TabPlaneDragger_handle(self, *args)

    def setupDefaultGeometry(self, twoSidedHandle=True):
        """
        setupDefaultGeometry(TabPlaneDragger self, bool twoSidedHandle=True)
        setupDefaultGeometry(TabPlaneDragger self)
        """
        return _osgManipulator.TabPlaneDragger_setupDefaultGeometry(self, twoSidedHandle)

    def setPlaneColor(self, *args):
        """setPlaneColor(TabPlaneDragger self, Vec4f color)"""
        return _osgManipulator.TabPlaneDragger_setPlaneColor(self, *args)

TabPlaneDragger_swigregister = _osgManipulator.TabPlaneDragger_swigregister
TabPlaneDragger_swigregister(TabPlaneDragger)

OSGMANIPULATOR_TABPLANETRACKBALLDRAGGER = _osgManipulator.OSGMANIPULATOR_TABPLANETRACKBALLDRAGGER
class TabPlaneTrackballDragger(CompositeDragger):
    """Proxy of C++ osgManipulator::TabPlaneTrackballDragger class"""
    __swig_setmethods__ = {}
    for _s in [CompositeDragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TabPlaneTrackballDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [CompositeDragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TabPlaneTrackballDragger, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::TabPlaneTrackballDragger self) -> TabPlaneTrackballDragger"""
        this = _osgManipulator.new_TabPlaneTrackballDragger()
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(TabPlaneTrackballDragger self) -> Object"""
        return _osgManipulator.TabPlaneTrackballDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(TabPlaneTrackballDragger self, Object obj) -> bool"""
        return _osgManipulator.TabPlaneTrackballDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(TabPlaneTrackballDragger self) -> char const *"""
        return _osgManipulator.TabPlaneTrackballDragger_libraryName(self)

    def className(self):
        """className(TabPlaneTrackballDragger self) -> char const *"""
        return _osgManipulator.TabPlaneTrackballDragger_className(self)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(TabPlaneTrackballDragger self)"""
        return _osgManipulator.TabPlaneTrackballDragger_setupDefaultGeometry(self)

    def setPlaneColor(self, *args):
        """setPlaneColor(TabPlaneTrackballDragger self, Vec4f color)"""
        return _osgManipulator.TabPlaneTrackballDragger_setPlaneColor(self, *args)

TabPlaneTrackballDragger_swigregister = _osgManipulator.TabPlaneTrackballDragger_swigregister
TabPlaneTrackballDragger_swigregister(TabPlaneTrackballDragger)

OSGMANIPULATOR_TRACKBALLDRAGGER = _osgManipulator.OSGMANIPULATOR_TRACKBALLDRAGGER
class TrackballDragger(CompositeDragger):
    """Proxy of C++ osgManipulator::TrackballDragger class"""
    __swig_setmethods__ = {}
    for _s in [CompositeDragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TrackballDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [CompositeDragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TrackballDragger, name)
    __repr__ = _swig_repr
    def __init__(self, useAutoTransform=False):
        """
        __init__(osgManipulator::TrackballDragger self, bool useAutoTransform=False) -> TrackballDragger
        __init__(osgManipulator::TrackballDragger self) -> TrackballDragger
        """
        this = _osgManipulator.new_TrackballDragger(useAutoTransform)
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(TrackballDragger self) -> Object"""
        return _osgManipulator.TrackballDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(TrackballDragger self, Object obj) -> bool"""
        return _osgManipulator.TrackballDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(TrackballDragger self) -> char const *"""
        return _osgManipulator.TrackballDragger_libraryName(self)

    def className(self):
        """className(TrackballDragger self) -> char const *"""
        return _osgManipulator.TrackballDragger_className(self)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(TrackballDragger self)"""
        return _osgManipulator.TrackballDragger_setupDefaultGeometry(self)

TrackballDragger_swigregister = _osgManipulator.TrackballDragger_swigregister
TrackballDragger_swigregister(TrackballDragger)

OSGMANIPULATOR_TRANSLATE1DDRAGGER = _osgManipulator.OSGMANIPULATOR_TRANSLATE1DDRAGGER
class Translate1DDragger(Dragger):
    """Proxy of C++ osgManipulator::Translate1DDragger class"""
    __swig_setmethods__ = {}
    for _s in [Dragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Translate1DDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [Dragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Translate1DDragger, name)
    __repr__ = _swig_repr
    def cloneType(self):
        """cloneType(Translate1DDragger self) -> Object"""
        return _osgManipulator.Translate1DDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(Translate1DDragger self, Object obj) -> bool"""
        return _osgManipulator.Translate1DDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(Translate1DDragger self) -> char const *"""
        return _osgManipulator.Translate1DDragger_libraryName(self)

    def className(self):
        """className(Translate1DDragger self) -> char const *"""
        return _osgManipulator.Translate1DDragger_className(self)

    def __init__(self, *args):
        """
        __init__(osgManipulator::Translate1DDragger self) -> Translate1DDragger
        __init__(osgManipulator::Translate1DDragger self, Vec3d s, Vec3d e) -> Translate1DDragger
        """
        this = _osgManipulator.new_Translate1DDragger(*args)
        try: self.this.append(this)
        except: self.this = this
    def handle(self, *args):
        """handle(Translate1DDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.Translate1DDragger_handle(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(Translate1DDragger self)"""
        return _osgManipulator.Translate1DDragger_setupDefaultGeometry(self)

    def setColor(self, *args):
        """setColor(Translate1DDragger self, Vec4f color)"""
        return _osgManipulator.Translate1DDragger_setColor(self, *args)

    def getColor(self):
        """getColor(Translate1DDragger self) -> Vec4f"""
        return _osgManipulator.Translate1DDragger_getColor(self)

    def setPickColor(self, *args):
        """setPickColor(Translate1DDragger self, Vec4f color)"""
        return _osgManipulator.Translate1DDragger_setPickColor(self, *args)

    def getPickColor(self):
        """getPickColor(Translate1DDragger self) -> Vec4f"""
        return _osgManipulator.Translate1DDragger_getPickColor(self)

    def setCheckForNodeInNodePath(self, *args):
        """setCheckForNodeInNodePath(Translate1DDragger self, bool onOff)"""
        return _osgManipulator.Translate1DDragger_setCheckForNodeInNodePath(self, *args)

Translate1DDragger_swigregister = _osgManipulator.Translate1DDragger_swigregister
Translate1DDragger_swigregister(Translate1DDragger)

OSGMANIPULATOR_TRANSLATE2DDRAGGER = _osgManipulator.OSGMANIPULATOR_TRANSLATE2DDRAGGER
class Translate2DDragger(Dragger):
    """Proxy of C++ osgManipulator::Translate2DDragger class"""
    __swig_setmethods__ = {}
    for _s in [Dragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Translate2DDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [Dragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Translate2DDragger, name)
    __repr__ = _swig_repr
    def __init__(self, *args):
        """
        __init__(osgManipulator::Translate2DDragger self) -> Translate2DDragger
        __init__(osgManipulator::Translate2DDragger self, Plane plane) -> Translate2DDragger
        """
        this = _osgManipulator.new_Translate2DDragger(*args)
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(Translate2DDragger self) -> Object"""
        return _osgManipulator.Translate2DDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(Translate2DDragger self, Object obj) -> bool"""
        return _osgManipulator.Translate2DDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(Translate2DDragger self) -> char const *"""
        return _osgManipulator.Translate2DDragger_libraryName(self)

    def className(self):
        """className(Translate2DDragger self) -> char const *"""
        return _osgManipulator.Translate2DDragger_className(self)

    def handle(self, *args):
        """handle(Translate2DDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.Translate2DDragger_handle(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(Translate2DDragger self)"""
        return _osgManipulator.Translate2DDragger_setupDefaultGeometry(self)

    def setColor(self, *args):
        """setColor(Translate2DDragger self, Vec4f color)"""
        return _osgManipulator.Translate2DDragger_setColor(self, *args)

    def getColor(self):
        """getColor(Translate2DDragger self) -> Vec4f"""
        return _osgManipulator.Translate2DDragger_getColor(self)

    def setPickColor(self, *args):
        """setPickColor(Translate2DDragger self, Vec4f color)"""
        return _osgManipulator.Translate2DDragger_setPickColor(self, *args)

    def getPickColor(self):
        """getPickColor(Translate2DDragger self) -> Vec4f"""
        return _osgManipulator.Translate2DDragger_getPickColor(self)

Translate2DDragger_swigregister = _osgManipulator.Translate2DDragger_swigregister
Translate2DDragger_swigregister(Translate2DDragger)

OSGMANIPULATOR_TRANSLATEAXISDRAGGER = _osgManipulator.OSGMANIPULATOR_TRANSLATEAXISDRAGGER
class TranslateAxisDragger(CompositeDragger):
    """Proxy of C++ osgManipulator::TranslateAxisDragger class"""
    __swig_setmethods__ = {}
    for _s in [CompositeDragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TranslateAxisDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [CompositeDragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TranslateAxisDragger, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::TranslateAxisDragger self) -> TranslateAxisDragger"""
        this = _osgManipulator.new_TranslateAxisDragger()
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(TranslateAxisDragger self) -> Object"""
        return _osgManipulator.TranslateAxisDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(TranslateAxisDragger self, Object obj) -> bool"""
        return _osgManipulator.TranslateAxisDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(TranslateAxisDragger self) -> char const *"""
        return _osgManipulator.TranslateAxisDragger_libraryName(self)

    def className(self):
        """className(TranslateAxisDragger self) -> char const *"""
        return _osgManipulator.TranslateAxisDragger_className(self)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(TranslateAxisDragger self)"""
        return _osgManipulator.TranslateAxisDragger_setupDefaultGeometry(self)

TranslateAxisDragger_swigregister = _osgManipulator.TranslateAxisDragger_swigregister
TranslateAxisDragger_swigregister(TranslateAxisDragger)

OSGMANIPULATOR_TRANSLATEPLANEDRAGGER = _osgManipulator.OSGMANIPULATOR_TRANSLATEPLANEDRAGGER
class TranslatePlaneDragger(CompositeDragger):
    """Proxy of C++ osgManipulator::TranslatePlaneDragger class"""
    __swig_setmethods__ = {}
    for _s in [CompositeDragger]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TranslatePlaneDragger, name, value)
    __swig_getmethods__ = {}
    for _s in [CompositeDragger]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TranslatePlaneDragger, name)
    __repr__ = _swig_repr
    def __init__(self):
        """__init__(osgManipulator::TranslatePlaneDragger self) -> TranslatePlaneDragger"""
        this = _osgManipulator.new_TranslatePlaneDragger()
        try: self.this.append(this)
        except: self.this = this
    def cloneType(self):
        """cloneType(TranslatePlaneDragger self) -> Object"""
        return _osgManipulator.TranslatePlaneDragger_cloneType(self)

    def isSameKindAs(self, *args):
        """isSameKindAs(TranslatePlaneDragger self, Object obj) -> bool"""
        return _osgManipulator.TranslatePlaneDragger_isSameKindAs(self, *args)

    def libraryName(self):
        """libraryName(TranslatePlaneDragger self) -> char const *"""
        return _osgManipulator.TranslatePlaneDragger_libraryName(self)

    def className(self):
        """className(TranslatePlaneDragger self) -> char const *"""
        return _osgManipulator.TranslatePlaneDragger_className(self)

    def handle(self, *args):
        """handle(TranslatePlaneDragger self, PointerInfo pi, osgGA::GUIEventAdapter const & ea, osgGA::GUIActionAdapter & us) -> bool"""
        return _osgManipulator.TranslatePlaneDragger_handle(self, *args)

    def setupDefaultGeometry(self):
        """setupDefaultGeometry(TranslatePlaneDragger self)"""
        return _osgManipulator.TranslatePlaneDragger_setupDefaultGeometry(self)

    def setColor(self, *args):
        """setColor(TranslatePlaneDragger self, Vec4f color)"""
        return _osgManipulator.TranslatePlaneDragger_setColor(self, *args)

    def getTranslate1DDragger(self):
        """getTranslate1DDragger(TranslatePlaneDragger self) -> Translate1DDragger"""
        return _osgManipulator.TranslatePlaneDragger_getTranslate1DDragger(self)

    def getTranslate2DDragger(self):
        """getTranslate2DDragger(TranslatePlaneDragger self) -> Translate2DDragger"""
        return _osgManipulator.TranslatePlaneDragger_getTranslate2DDragger(self)

TranslatePlaneDragger_swigregister = _osgManipulator.TranslatePlaneDragger_swigregister
TranslatePlaneDragger_swigregister(TranslatePlaneDragger)

def NodeToDragger(*args):
  """NodeToDragger(Node d) -> Dragger"""
  return _osgManipulator.NodeToDragger(*args)

def NodeToSelection(*args):
  """NodeToSelection(Node d) -> MatrixTransform"""
  return _osgManipulator.NodeToSelection(*args)
# osgManipulator.Selection is a typedef alias for osg.MatrixTransform (at least in osg 3.2.1)
Selection = osg.MatrixTransform

# This file is compatible with both classic and new-style classes.