# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _pyIFC
def _swig_setattr(self,class_type,name,value):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    self.__dict__[name] = value

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

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


IMM_VERSION = _pyIFC.IMM_VERSION
IMM_DEVICETYPE_DEVICE = _pyIFC.IMM_DEVICETYPE_DEVICE
IMM_DEVICETYPE_MOUSE = _pyIFC.IMM_DEVICETYPE_MOUSE
IMM_DEVICETYPE_DIRECTINPUT = _pyIFC.IMM_DEVICETYPE_DIRECTINPUT
IMM_EFFECTTYPE_ALL = _pyIFC.IMM_EFFECTTYPE_ALL
IMM_EFFECTTYPE_CONSTANTFORCE = _pyIFC.IMM_EFFECTTYPE_CONSTANTFORCE
IMM_EFFECTTYPE_RAMPFORCE = _pyIFC.IMM_EFFECTTYPE_RAMPFORCE
IMM_EFFECTTYPE_PERIODIC = _pyIFC.IMM_EFFECTTYPE_PERIODIC
IMM_EFFECTTYPE_CONDITION = _pyIFC.IMM_EFFECTTYPE_CONDITION
IMM_EFFECTTYPE_ENCLOSURE = _pyIFC.IMM_EFFECTTYPE_ENCLOSURE
IMM_EFFECTTYPE_ELLIPSE = _pyIFC.IMM_EFFECTTYPE_ELLIPSE
IMM_EFFECTTYPE_TEXTURE = _pyIFC.IMM_EFFECTTYPE_TEXTURE
IMM_EFFECTTYPE_COMPOUND = _pyIFC.IMM_EFFECTTYPE_COMPOUND
IMM_EFFECTTYPE_CUSTOMFORCE = _pyIFC.IMM_EFFECTTYPE_CUSTOMFORCE
IMM_EFFECTTYPE_HARDWARE = _pyIFC.IMM_EFFECTTYPE_HARDWARE
IMM_EFFECTTYPE_FFATTACK = _pyIFC.IMM_EFFECTTYPE_FFATTACK
IMM_EFFECTTYPE_FFFADE = _pyIFC.IMM_EFFECTTYPE_FFFADE
IMM_EFFECTTYPE_SATURATION = _pyIFC.IMM_EFFECTTYPE_SATURATION
IMM_EFFECTTYPE_POSNEGCOEFFICIENTS = _pyIFC.IMM_EFFECTTYPE_POSNEGCOEFFICIENTS
IMM_EFFECTTYPE_POSNEGSATURATION = _pyIFC.IMM_EFFECTTYPE_POSNEGSATURATION
IMM_EFFECTTYPE_DEADBAND = _pyIFC.IMM_EFFECTTYPE_DEADBAND
IMM_DEGREES = _pyIFC.IMM_DEGREES
IMM_FFNOMINALMAX = _pyIFC.IMM_FFNOMINALMAX
IMM_SECONDS = _pyIFC.IMM_SECONDS
IMM_START_SOLO = _pyIFC.IMM_START_SOLO
IMM_START_NODOWNLOAD = _pyIFC.IMM_START_NODOWNLOAD
IMM_STATUS_PLAYING = _pyIFC.IMM_STATUS_PLAYING
IMM_STATUS_EMULATED = _pyIFC.IMM_STATUS_EMULATED
IMM_STIFF_NONE = _pyIFC.IMM_STIFF_NONE
IMM_STIFF_OUTERLEFTWALL = _pyIFC.IMM_STIFF_OUTERLEFTWALL
IMM_STIFF_INNERLEFTWALL = _pyIFC.IMM_STIFF_INNERLEFTWALL
IMM_STIFF_INNERRIGHTWALL = _pyIFC.IMM_STIFF_INNERRIGHTWALL
IMM_STIFF_OUTERRIGHTWALL = _pyIFC.IMM_STIFF_OUTERRIGHTWALL
IMM_STIFF_OUTERTOPWALL = _pyIFC.IMM_STIFF_OUTERTOPWALL
IMM_STIFF_INNERTOPWALL = _pyIFC.IMM_STIFF_INNERTOPWALL
IMM_STIFF_INNERBOTTOMWALL = _pyIFC.IMM_STIFF_INNERBOTTOMWALL
IMM_STIFF_OUTERBOTTOMWALL = _pyIFC.IMM_STIFF_OUTERBOTTOMWALL
IMM_STIFF_OUTERANYWALL = _pyIFC.IMM_STIFF_OUTERANYWALL
IMM_STIFF_INBOUNDANYWALL = _pyIFC.IMM_STIFF_INBOUNDANYWALL
IMM_STIFF_INNERANYWALL = _pyIFC.IMM_STIFF_INNERANYWALL
IMM_STIFF_OUTBOUNDANYWALL = _pyIFC.IMM_STIFF_OUTBOUNDANYWALL
IMM_STIFF_ANYWALL = _pyIFC.IMM_STIFF_ANYWALL
IMM_CLIP_NONE = _pyIFC.IMM_CLIP_NONE
IMM_CLIP_OUTERLEFTWALL = _pyIFC.IMM_CLIP_OUTERLEFTWALL
IMM_CLIP_INNERLEFTWALL = _pyIFC.IMM_CLIP_INNERLEFTWALL
IMM_CLIP_INNERRIGHTWALL = _pyIFC.IMM_CLIP_INNERRIGHTWALL
IMM_CLIP_OUTERRIGHTWALL = _pyIFC.IMM_CLIP_OUTERRIGHTWALL
IMM_CLIP_OUTERTOPWALL = _pyIFC.IMM_CLIP_OUTERTOPWALL
IMM_CLIP_INNERTOPWALL = _pyIFC.IMM_CLIP_INNERTOPWALL
IMM_CLIP_INNERBOTTOMWALL = _pyIFC.IMM_CLIP_INNERBOTTOMWALL
IMM_CLIP_OUTERBOTTOMWALL = _pyIFC.IMM_CLIP_OUTERBOTTOMWALL
IMM_CLIP_OUTERANYWALL = _pyIFC.IMM_CLIP_OUTERANYWALL
IMM_CLIP_INNERANYWALL = _pyIFC.IMM_CLIP_INNERANYWALL
IMM_CLIP_ANYWALL = _pyIFC.IMM_CLIP_ANYWALL
IMM_DEVCAPS_ATTACHED = _pyIFC.IMM_DEVCAPS_ATTACHED
IMM_DEVCAPS_POLLEDDEVICE = _pyIFC.IMM_DEVCAPS_POLLEDDEVICE
IMM_DEVCAPS_EMULATED = _pyIFC.IMM_DEVCAPS_EMULATED
IMM_DEVCAPS_POLLEDDATAFORMAT = _pyIFC.IMM_DEVCAPS_POLLEDDATAFORMAT
IMM_DEVCAPS_FORCEFEEDBACK = _pyIFC.IMM_DEVCAPS_FORCEFEEDBACK
IMM_DEVCAPS_FFATTACK = _pyIFC.IMM_DEVCAPS_FFATTACK
IMM_DEVCAPS_FFFADE = _pyIFC.IMM_DEVCAPS_FFFADE
IMM_DEVCAPS_SATURATION = _pyIFC.IMM_DEVCAPS_SATURATION
IMM_DEVCAPS_POSNEGCOEFFICIENTS = _pyIFC.IMM_DEVCAPS_POSNEGCOEFFICIENTS
IMM_DEVCAPS_POSNEGSATURATION = _pyIFC.IMM_DEVCAPS_POSNEGSATURATION
IMM_DEVCAPS_DEADBAND = _pyIFC.IMM_DEVCAPS_DEADBAND
IMM_PARAM_DURATION = _pyIFC.IMM_PARAM_DURATION
IMM_PARAM_SAMPLEPERIOD = _pyIFC.IMM_PARAM_SAMPLEPERIOD
IMM_PARAM_GAIN = _pyIFC.IMM_PARAM_GAIN
IMM_PARAM_TRIGGERBUTTON = _pyIFC.IMM_PARAM_TRIGGERBUTTON
IMM_PARAM_TRIGGERREPEATINTERVAL = _pyIFC.IMM_PARAM_TRIGGERREPEATINTERVAL
IMM_PARAM_AXES = _pyIFC.IMM_PARAM_AXES
IMM_PARAM_DIRECTION = _pyIFC.IMM_PARAM_DIRECTION
IMM_PARAM_ENVELOPE = _pyIFC.IMM_PARAM_ENVELOPE
IMM_PARAM_TYPESPECIFICPARAMS = _pyIFC.IMM_PARAM_TYPESPECIFICPARAMS
IMM_PARAM_STARTDELAY = _pyIFC.IMM_PARAM_STARTDELAY
IMM_PARAM_ALLPARAMS = _pyIFC.IMM_PARAM_ALLPARAMS
IMM_PARAM_START = _pyIFC.IMM_PARAM_START
IMM_PARAM_NORESTART = _pyIFC.IMM_PARAM_NORESTART
IMM_PARAM_NODOWNLOAD = _pyIFC.IMM_PARAM_NODOWNLOAD
IMM_EFFECT_OBJECTIDS = _pyIFC.IMM_EFFECT_OBJECTIDS
IMM_EFFECT_OBJECTOFFSETS = _pyIFC.IMM_EFFECT_OBJECTOFFSETS
IMM_EFFECT_CARTESIAN = _pyIFC.IMM_EFFECT_CARTESIAN
IMM_EFFECT_POLAR = _pyIFC.IMM_EFFECT_POLAR
IMM_EFFECT_SPHERICAL = _pyIFC.IMM_EFFECT_SPHERICAL
IMM_PARAM_NOTRIGGER = _pyIFC.IMM_PARAM_NOTRIGGER
IMM_MOUSEOFFSET_XAXIS = _pyIFC.IMM_MOUSEOFFSET_XAXIS
IMM_MOUSEOFFSET_YAXIS = _pyIFC.IMM_MOUSEOFFSET_YAXIS
IMM_MOUSEOFFSET_ZAXIS = _pyIFC.IMM_MOUSEOFFSET_ZAXIS
IMM_MOUSEOFFSET_XFORCE = _pyIFC.IMM_MOUSEOFFSET_XFORCE
IMM_MOUSEOFFSET_YFORCE = _pyIFC.IMM_MOUSEOFFSET_YFORCE
IMM_MOUSEOFFSET_ZFORCE = _pyIFC.IMM_MOUSEOFFSET_ZFORCE
IMM_MOUSEOFFSET_BUTTON0 = _pyIFC.IMM_MOUSEOFFSET_BUTTON0
IMM_MOUSEOFFSET_BUTTON1 = _pyIFC.IMM_MOUSEOFFSET_BUTTON1
IMM_MOUSEOFFSET_BUTTON2 = _pyIFC.IMM_MOUSEOFFSET_BUTTON2
IMM_MOUSEOFFSET_BUTTON3 = _pyIFC.IMM_MOUSEOFFSET_BUTTON3
IMM_COOPLEVEL_FOREGROUND = _pyIFC.IMM_COOPLEVEL_FOREGROUND
IMM_COOPLEVEL_BACKGROUND = _pyIFC.IMM_COOPLEVEL_BACKGROUND
IMM_ENUM_STOP = _pyIFC.IMM_ENUM_STOP
IMM_ENUM_CONTINUE = _pyIFC.IMM_ENUM_CONTINUE
IMM_ENUMDEV_ALLDEVICES = _pyIFC.IMM_ENUMDEV_ALLDEVICES
IMM_ENUMDEV_ATTACHEDONLY = _pyIFC.IMM_ENUMDEV_ATTACHEDONLY
IMM_ENUMDEV_FORCEFEEDBACK = _pyIFC.IMM_ENUMDEV_FORCEFEEDBACK
IMM_RESULT_OK = _pyIFC.IMM_RESULT_OK
IMM_RESULT_NOTATTACHED = _pyIFC.IMM_RESULT_NOTATTACHED
IMM_RESULT_BUFFEROVERFLOW = _pyIFC.IMM_RESULT_BUFFEROVERFLOW
IMM_RESULT_PROPNOEFFECT = _pyIFC.IMM_RESULT_PROPNOEFFECT
IMM_RESULT_NOEFFECT = _pyIFC.IMM_RESULT_NOEFFECT
IMM_RESULT_POLLEDDEVICE = _pyIFC.IMM_RESULT_POLLEDDEVICE
IMM_RESULT_DOWNLOADSKIPPED = _pyIFC.IMM_RESULT_DOWNLOADSKIPPED
IMM_RESULT_EFFECTRESTARTED = _pyIFC.IMM_RESULT_EFFECTRESTARTED
IMM_RESULT_TRUNCATED = _pyIFC.IMM_RESULT_TRUNCATED
IMM_RESULT_TRUNCATEDANDRESTARTED = _pyIFC.IMM_RESULT_TRUNCATEDANDRESTARTED
IMM_ERROR_OLDFEELITVERSION = _pyIFC.IMM_ERROR_OLDFEELITVERSION
IMM_ERROR_BETAFEELITVERSION = _pyIFC.IMM_ERROR_BETAFEELITVERSION
IMM_ERROR_BADDRIVERVER = _pyIFC.IMM_ERROR_BADDRIVERVER
IMM_ERROR_DEVICENOTREG = _pyIFC.IMM_ERROR_DEVICENOTREG
IMM_ERROR_NOTFOUND = _pyIFC.IMM_ERROR_NOTFOUND
IMM_ERROR_OBJECTNOTFOUND = _pyIFC.IMM_ERROR_OBJECTNOTFOUND
IMM_ERROR_INVALIDPARAM = _pyIFC.IMM_ERROR_INVALIDPARAM
IMM_ERROR_NOINTERFACE = _pyIFC.IMM_ERROR_NOINTERFACE
IMM_ERROR_GENERIC = _pyIFC.IMM_ERROR_GENERIC
IMM_ERROR_OUTOFMEMORY = _pyIFC.IMM_ERROR_OUTOFMEMORY
IMM_ERROR_UNSUPPORTED = _pyIFC.IMM_ERROR_UNSUPPORTED
IMM_ERROR_NOTINITIALIZED = _pyIFC.IMM_ERROR_NOTINITIALIZED
IMM_ERROR_ALREADYINITIALIZED = _pyIFC.IMM_ERROR_ALREADYINITIALIZED
IMM_ERROR_NOAGGREGATION = _pyIFC.IMM_ERROR_NOAGGREGATION
IMM_ERROR_OTHERAPPHASPRIO = _pyIFC.IMM_ERROR_OTHERAPPHASPRIO
IMM_ERROR_INPUTLOST = _pyIFC.IMM_ERROR_INPUTLOST
IMM_ERROR_ACQUIRED = _pyIFC.IMM_ERROR_ACQUIRED
IMM_ERROR_NOTACQUIRED = _pyIFC.IMM_ERROR_NOTACQUIRED
IMM_ERROR_READONLY = _pyIFC.IMM_ERROR_READONLY
IMM_ERROR_HANDLEEXISTS = _pyIFC.IMM_ERROR_HANDLEEXISTS
IMM_ERROR_INSUFFICIENTPRIVS = _pyIFC.IMM_ERROR_INSUFFICIENTPRIVS
IMM_ERROR_DEVICEFULL = _pyIFC.IMM_ERROR_DEVICEFULL
IMM_ERROR_MOREDATA = _pyIFC.IMM_ERROR_MOREDATA
IMM_ERROR_NOTDOWNLOADED = _pyIFC.IMM_ERROR_NOTDOWNLOADED
IMM_ERROR_HASEFFECTS = _pyIFC.IMM_ERROR_HASEFFECTS
IMM_ERROR_NOTEXCLUSIVEACQUIRED = _pyIFC.IMM_ERROR_NOTEXCLUSIVEACQUIRED
IMM_ERROR_INCOMPLETEEFFECT = _pyIFC.IMM_ERROR_INCOMPLETEEFFECT
IMM_ERROR_NOTBUFFERED = _pyIFC.IMM_ERROR_NOTBUFFERED
IMM_ERROR_EFFECTPLAYING = _pyIFC.IMM_ERROR_EFFECTPLAYING
IMM_ERROR_INACTIVE = _pyIFC.IMM_ERROR_INACTIVE
IMM_BOX_DEFAULT_STIFFNESS = _pyIFC.IMM_BOX_DEFAULT_STIFFNESS
IMM_BOX_DEFAULT_WIDTH = _pyIFC.IMM_BOX_DEFAULT_WIDTH
IMM_BOX_DEFAULT_HEIGHT = _pyIFC.IMM_BOX_DEFAULT_HEIGHT
IMM_BOX_DEFAULT_WALL_WIDTH = _pyIFC.IMM_BOX_DEFAULT_WALL_WIDTH
IMM_CONDITION_DEFAULT_COEFFICIENT = _pyIFC.IMM_CONDITION_DEFAULT_COEFFICIENT
IMM_CONDITION_DEFAULT_SATURATION = _pyIFC.IMM_CONDITION_DEFAULT_SATURATION
IMM_CONDITION_DEFAULT_DEADBAND = _pyIFC.IMM_CONDITION_DEFAULT_DEADBAND
IMM_CONDITION_DEFAULT_DURATION = _pyIFC.IMM_CONDITION_DEFAULT_DURATION
IMM_CONSTANT_DEFAULT_DURATION = _pyIFC.IMM_CONSTANT_DEFAULT_DURATION
IMM_CONSTANT_DEFAULT_MAGNITUDE = _pyIFC.IMM_CONSTANT_DEFAULT_MAGNITUDE
IMM_DAMPER_DEFAULT_VISCOSITY = _pyIFC.IMM_DAMPER_DEFAULT_VISCOSITY
IMM_DAMPER_DEFAULT_SATURATION = _pyIFC.IMM_DAMPER_DEFAULT_SATURATION
IMM_DAMPER_DEFAULT_MIN_VELOCITY = _pyIFC.IMM_DAMPER_DEFAULT_MIN_VELOCITY
IMM_EFFECT_AXIS_X = _pyIFC.IMM_EFFECT_AXIS_X
IMM_EFFECT_AXIS_Y = _pyIFC.IMM_EFFECT_AXIS_Y
IMM_EFFECT_AXIS_BOTH = _pyIFC.IMM_EFFECT_AXIS_BOTH
IMM_EFFECT_AXIS_DIRECTIONAL = _pyIFC.IMM_EFFECT_AXIS_DIRECTIONAL
IMM_EFFECT_DONT_CHANGE = _pyIFC.IMM_EFFECT_DONT_CHANGE
IMM_EFFECT_DONT_CHANGE_PTR = _pyIFC.IMM_EFFECT_DONT_CHANGE_PTR
IMM_EFFECT_DEFAULT_ENVELOPE = _pyIFC.IMM_EFFECT_DEFAULT_ENVELOPE
IMM_EFFECT_DEFAULT_DIRECTION_X = _pyIFC.IMM_EFFECT_DEFAULT_DIRECTION_X
IMM_EFFECT_DEFAULT_DIRECTION_Y = _pyIFC.IMM_EFFECT_DEFAULT_DIRECTION_Y
IMM_EFFECT_DEFAULT_ANGLE = _pyIFC.IMM_EFFECT_DEFAULT_ANGLE
IMM_ELLIPSE_DEFAULT_STIFFNESS = _pyIFC.IMM_ELLIPSE_DEFAULT_STIFFNESS
IMM_ELLIPSE_DEFAULT_SATURATION = _pyIFC.IMM_ELLIPSE_DEFAULT_SATURATION
IMM_ELLIPSE_DEFAULT_WIDTH = _pyIFC.IMM_ELLIPSE_DEFAULT_WIDTH
IMM_ELLIPSE_HEIGHT_AUTO = _pyIFC.IMM_ELLIPSE_HEIGHT_AUTO
IMM_ELLIPSE_DEFAULT_HEIGHT = _pyIFC.IMM_ELLIPSE_DEFAULT_HEIGHT
IMM_ELLIPSE_WALL_WIDTH_AUTO = _pyIFC.IMM_ELLIPSE_WALL_WIDTH_AUTO
IMM_ELLIPSE_DEFAULT_WALL_WIDTH = _pyIFC.IMM_ELLIPSE_DEFAULT_WALL_WIDTH
IMM_ELLIPSE_DEFAULT_STIFFNESS_MASK = _pyIFC.IMM_ELLIPSE_DEFAULT_STIFFNESS_MASK
IMM_ELLIPSE_DEFAULT_CLIPPING_MASK = _pyIFC.IMM_ELLIPSE_DEFAULT_CLIPPING_MASK
IMM_ENCLOSURE_DEFAULT_STIFFNESS = _pyIFC.IMM_ENCLOSURE_DEFAULT_STIFFNESS
IMM_ENCLOSURE_DEFAULT_SATURATION = _pyIFC.IMM_ENCLOSURE_DEFAULT_SATURATION
IMM_ENCLOSURE_DEFAULT_WIDTH = _pyIFC.IMM_ENCLOSURE_DEFAULT_WIDTH
IMM_ENCLOSURE_HEIGHT_AUTO = _pyIFC.IMM_ENCLOSURE_HEIGHT_AUTO
IMM_ENCLOSURE_DEFAULT_HEIGHT = _pyIFC.IMM_ENCLOSURE_DEFAULT_HEIGHT
IMM_ENCLOSURE_WALL_WIDTH_AUTO = _pyIFC.IMM_ENCLOSURE_WALL_WIDTH_AUTO
IMM_ENCLOSURE_DEFAULT_WALL_WIDTH = _pyIFC.IMM_ENCLOSURE_DEFAULT_WALL_WIDTH
IMM_ENCLOSURE_DEFAULT_STIFFNESS_MASK = _pyIFC.IMM_ENCLOSURE_DEFAULT_STIFFNESS_MASK
IMM_ENCLOSURE_DEFAULT_CLIPPING_MASK = _pyIFC.IMM_ENCLOSURE_DEFAULT_CLIPPING_MASK
IMM_FRICTION_DEFAULT_COEFFICIENT = _pyIFC.IMM_FRICTION_DEFAULT_COEFFICIENT
IMM_FRICTION_DEFAULT_MIN_VELOCITY = _pyIFC.IMM_FRICTION_DEFAULT_MIN_VELOCITY
IMM_GRID_DEFAULT_HORIZ_OFFSET = _pyIFC.IMM_GRID_DEFAULT_HORIZ_OFFSET
IMM_GRID_DEFAULT_VERT_OFFSET = _pyIFC.IMM_GRID_DEFAULT_VERT_OFFSET
IMM_GRID_DEFAULT_HORIZ_SPACING = _pyIFC.IMM_GRID_DEFAULT_HORIZ_SPACING
IMM_GRID_DEFAULT_VERT_SPACING = _pyIFC.IMM_GRID_DEFAULT_VERT_SPACING
IMM_GRID_DEFAULT_NODE_STRENGTH = _pyIFC.IMM_GRID_DEFAULT_NODE_STRENGTH
IMM_GRID_DEFAULT_NODE_SATURATION = _pyIFC.IMM_GRID_DEFAULT_NODE_SATURATION
IMM_INERTIA_DEFAULT_COEFFICIENT = _pyIFC.IMM_INERTIA_DEFAULT_COEFFICIENT
IMM_INERTIA_DEFAULT_SATURATION = _pyIFC.IMM_INERTIA_DEFAULT_SATURATION
IMM_INERTIA_DEFAULT_MIN_ACCELERATION = _pyIFC.IMM_INERTIA_DEFAULT_MIN_ACCELERATION
IMM_PERIODIC_DEFAULT_DURATION = _pyIFC.IMM_PERIODIC_DEFAULT_DURATION
IMM_PERIODIC_DEFAULT_MAGNITUDE = _pyIFC.IMM_PERIODIC_DEFAULT_MAGNITUDE
IMM_PERIODIC_DEFAULT_PERIOD = _pyIFC.IMM_PERIODIC_DEFAULT_PERIOD
IMM_PERIODIC_DEFAULT_OFFSET = _pyIFC.IMM_PERIODIC_DEFAULT_OFFSET
IMM_PERIODIC_DEFAULT_PHASE = _pyIFC.IMM_PERIODIC_DEFAULT_PHASE
IMM_PERIODIC_DEFAULT_DIRECTION_X = _pyIFC.IMM_PERIODIC_DEFAULT_DIRECTION_X
IMM_PERIODIC_DEFAULT_DIRECTION_Y = _pyIFC.IMM_PERIODIC_DEFAULT_DIRECTION_Y
IMM_PERIODIC_DEFAULT_ANGLE = _pyIFC.IMM_PERIODIC_DEFAULT_ANGLE
IMM_RAMP_DEFAULT_DURATION = _pyIFC.IMM_RAMP_DEFAULT_DURATION
IMM_RAMP_DEFAULT_MAGNITUDE_START = _pyIFC.IMM_RAMP_DEFAULT_MAGNITUDE_START
IMM_RAMP_DEFAULT_MAGNITUDE_END = _pyIFC.IMM_RAMP_DEFAULT_MAGNITUDE_END
IMM_SPRING_DEFAULT_STIFFNESS = _pyIFC.IMM_SPRING_DEFAULT_STIFFNESS
IMM_SPRING_DEFAULT_SATURATION = _pyIFC.IMM_SPRING_DEFAULT_SATURATION
IMM_SPRING_DEFAULT_DEADBAND = _pyIFC.IMM_SPRING_DEFAULT_DEADBAND
IMM_SPRING_DEFAULT_DIRECTION_X = _pyIFC.IMM_SPRING_DEFAULT_DIRECTION_X
IMM_SPRING_DEFAULT_DIRECTION_Y = _pyIFC.IMM_SPRING_DEFAULT_DIRECTION_Y
IMM_SPRING_DEFAULT_ANGLE = _pyIFC.IMM_SPRING_DEFAULT_ANGLE
IMM_TEXTURE_DEFAULT_MAGNITUDE = _pyIFC.IMM_TEXTURE_DEFAULT_MAGNITUDE
IMM_TEXTURE_DEFAULT_WIDTH = _pyIFC.IMM_TEXTURE_DEFAULT_WIDTH
IMM_TEXTURE_DEFAULT_SPACING = _pyIFC.IMM_TEXTURE_DEFAULT_SPACING
IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT = _pyIFC.IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT
IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE = _pyIFC.IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE
class IMM_ENVELOPE(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMM_ENVELOPE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMM_ENVELOPE, name)
    __swig_setmethods__["dwAttackLevel"] = _pyIFC.IMM_ENVELOPE_dwAttackLevel_set
    __swig_getmethods__["dwAttackLevel"] = _pyIFC.IMM_ENVELOPE_dwAttackLevel_get
    if _newclass:dwAttackLevel = property(_pyIFC.IMM_ENVELOPE_dwAttackLevel_get,_pyIFC.IMM_ENVELOPE_dwAttackLevel_set)
    __swig_setmethods__["dwAttackTime"] = _pyIFC.IMM_ENVELOPE_dwAttackTime_set
    __swig_getmethods__["dwAttackTime"] = _pyIFC.IMM_ENVELOPE_dwAttackTime_get
    if _newclass:dwAttackTime = property(_pyIFC.IMM_ENVELOPE_dwAttackTime_get,_pyIFC.IMM_ENVELOPE_dwAttackTime_set)
    __swig_setmethods__["dwFadeLevel"] = _pyIFC.IMM_ENVELOPE_dwFadeLevel_set
    __swig_getmethods__["dwFadeLevel"] = _pyIFC.IMM_ENVELOPE_dwFadeLevel_get
    if _newclass:dwFadeLevel = property(_pyIFC.IMM_ENVELOPE_dwFadeLevel_get,_pyIFC.IMM_ENVELOPE_dwFadeLevel_set)
    __swig_setmethods__["dwFadeTime"] = _pyIFC.IMM_ENVELOPE_dwFadeTime_set
    __swig_getmethods__["dwFadeTime"] = _pyIFC.IMM_ENVELOPE_dwFadeTime_get
    if _newclass:dwFadeTime = property(_pyIFC.IMM_ENVELOPE_dwFadeTime_get,_pyIFC.IMM_ENVELOPE_dwFadeTime_set)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_IMM_ENVELOPE,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_IMM_ENVELOPE):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C IMM_ENVELOPE instance at %s>" % (self.this,)

class IMM_ENVELOPEPtr(IMM_ENVELOPE):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = IMM_ENVELOPE
_pyIFC.IMM_ENVELOPE_swigregister(IMM_ENVELOPEPtr)

class CImmDevice(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmDevice, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CImmDevice, name)
    def __del__(self, destroy= _pyIFC.delete_CImmDevice):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetDeviceType(*args): return apply(_pyIFC.CImmDevice_GetDeviceType,args)
    def GetProductType(*args): return apply(_pyIFC.CImmDevice_GetProductType,args)
    def GetDriverVersion(*args): return apply(_pyIFC.CImmDevice_GetDriverVersion,args)
    def GetProductName(*args): return apply(_pyIFC.CImmDevice_GetProductName,args)
    def GetProductGUIDString(*args): return apply(_pyIFC.CImmDevice_GetProductGUIDString,args)
    def GetProductGUID(*args): return apply(_pyIFC.CImmDevice_GetProductGUID,args)
    __swig_getmethods__["GetImmAPIVersion"] = lambda x: _pyIFC.CImmDevice_GetImmAPIVersion
    if _newclass:GetImmAPIVersion = staticmethod(_pyIFC.CImmDevice_GetImmAPIVersion)
    __swig_getmethods__["GetDXVersion"] = lambda x: _pyIFC.CImmDevice_GetDXVersion
    if _newclass:GetDXVersion = staticmethod(_pyIFC.CImmDevice_GetDXVersion)
    def StopAll(*args): return apply(_pyIFC.CImmDevice_StopAll,args)
    __swig_getmethods__["CreateDevice"] = lambda x: _pyIFC.CImmDevice_CreateDevice
    if _newclass:CreateDevice = staticmethod(_pyIFC.CImmDevice_CreateDevice)
    def GetCurrentPosition(*args): return apply(_pyIFC.CImmDevice_GetCurrentPosition,args)
    def ChangeScreenResolution(*args): return apply(_pyIFC.CImmDevice_ChangeScreenResolution,args)
    def UsesWin32MouseServices(*args): return apply(_pyIFC.CImmDevice_UsesWin32MouseServices,args)
    def SwitchToAbsoluteMode(*args): return apply(_pyIFC.CImmDevice_SwitchToAbsoluteMode,args)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C CImmDevice instance at %s>" % (self.this,)

class CImmDevicePtr(CImmDevice):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmDevice
_pyIFC.CImmDevice_swigregister(CImmDevicePtr)
CImmDevice_GetImmAPIVersion = _pyIFC.CImmDevice_GetImmAPIVersion

CImmDevice_GetDXVersion = _pyIFC.CImmDevice_GetDXVersion

CImmDevice_CreateDevice = _pyIFC.CImmDevice_CreateDevice


class CImmCompoundEffect(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmCompoundEffect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CImmCompoundEffect, name)
    def __del__(self, destroy= _pyIFC.delete_CImmCompoundEffect):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetNumberOfContainedEffects(*args): return apply(_pyIFC.CImmCompoundEffect_GetNumberOfContainedEffects,args)
    def GetNumberOfContainedSounds(*args): return apply(_pyIFC.CImmCompoundEffect_GetNumberOfContainedSounds,args)
    def GetName(*args): return apply(_pyIFC.CImmCompoundEffect_GetName,args)
    def GetContainedEffectFromIndex(*args): return apply(_pyIFC.CImmCompoundEffect_GetContainedEffectFromIndex,args)
    def GetContainedEffect(*args): return apply(_pyIFC.CImmCompoundEffect_GetContainedEffect,args)
    def GetContainedSound(*args): return apply(_pyIFC.CImmCompoundEffect_GetContainedSound,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmCompoundEffect_GetEffectType,args)
    def GetTypeName(*args): return apply(_pyIFC.CImmCompoundEffect_GetTypeName,args)
    def Start(*args): return apply(_pyIFC.CImmCompoundEffect_Start,args)
    def Stop(*args): return apply(_pyIFC.CImmCompoundEffect_Stop,args)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C CImmCompoundEffect instance at %s>" % (self.this,)

class CImmCompoundEffectPtr(CImmCompoundEffect):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmCompoundEffect
_pyIFC.CImmCompoundEffect_swigregister(CImmCompoundEffectPtr)

class CImmEffect(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmEffect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CImmEffect, name)
    def GetDevice(*args): return apply(_pyIFC.CImmEffect_GetDevice,args)
    def GetStatus(*args): return apply(_pyIFC.CImmEffect_GetStatus,args)
    def GetEnvelope(*args): return apply(_pyIFC.CImmEffect_GetEnvelope,args)
    def GetDuration(*args): return apply(_pyIFC.CImmEffect_GetDuration,args)
    def GetGain(*args): return apply(_pyIFC.CImmEffect_GetGain,args)
    def GetStartDelay(*args): return apply(_pyIFC.CImmEffect_GetStartDelay,args)
    def GetTriggerButton(*args): return apply(_pyIFC.CImmEffect_GetTriggerButton,args)
    def GetTriggerRepeatInterval(*args): return apply(_pyIFC.CImmEffect_GetTriggerRepeatInterval,args)
    def GetDirectionXY(*args): return apply(_pyIFC.CImmEffect_GetDirectionXY,args)
    def GetDirectionAngle(*args): return apply(_pyIFC.CImmEffect_GetDirectionAngle,args)
    def GetIterations(*args): return apply(_pyIFC.CImmEffect_GetIterations,args)
    def GetGUID(*args): return apply(_pyIFC.CImmEffect_GetGUID,args)
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmEffect_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmEffect_GetEffectType,args)
    def GetName(*args): return apply(_pyIFC.CImmEffect_GetName,args)
    __swig_getmethods__["NewObjectFromGUID"] = lambda x: _pyIFC.CImmEffect_NewObjectFromGUID
    if _newclass:NewObjectFromGUID = staticmethod(_pyIFC.CImmEffect_NewObjectFromGUID)
    def ChangeBaseParams(*args): return apply(_pyIFC.CImmEffect_ChangeBaseParams,args)
    def ChangeBaseParamsPolar(*args): return apply(_pyIFC.CImmEffect_ChangeBaseParamsPolar,args)
    def ChangeDirectionXY(*args): return apply(_pyIFC.CImmEffect_ChangeDirectionXY,args)
    def ChangeDirectionAngle(*args): return apply(_pyIFC.CImmEffect_ChangeDirectionAngle,args)
    def ChangeDuration(*args): return apply(_pyIFC.CImmEffect_ChangeDuration,args)
    def ChangeGain(*args): return apply(_pyIFC.CImmEffect_ChangeGain,args)
    def ChangeStartDelay(*args): return apply(_pyIFC.CImmEffect_ChangeStartDelay,args)
    def ChangeTriggerButton(*args): return apply(_pyIFC.CImmEffect_ChangeTriggerButton,args)
    def ChangeTriggerRepeatInterval(*args): return apply(_pyIFC.CImmEffect_ChangeTriggerRepeatInterval,args)
    def ChangeIterations(*args): return apply(_pyIFC.CImmEffect_ChangeIterations,args)
    def ChangeEnvelope(*args): return apply(_pyIFC.CImmEffect_ChangeEnvelope,args)
    def Initialize(*args): return apply(_pyIFC.CImmEffect_Initialize,args)
    def InitializeFromProject(*args): return apply(_pyIFC.CImmEffect_InitializeFromProject,args)
    def Start(*args): return apply(_pyIFC.CImmEffect_Start,args)
    def Stop(*args): return apply(_pyIFC.CImmEffect_Stop,args)
    def __del__(self, destroy= _pyIFC.delete_CImmEffect):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C CImmEffect instance at %s>" % (self.this,)

class CImmEffectPtr(CImmEffect):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmEffect
_pyIFC.CImmEffect_swigregister(CImmEffectPtr)
CImmEffect_NewObjectFromGUID = _pyIFC.CImmEffect_NewObjectFromGUID


class CImmCondition(CImmEffect):
    __swig_setmethods__ = {}
    for _s in [CImmEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmCondition, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmCondition, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmCondition,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmCondition):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmCondition_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmCondition_GetEffectType,args)
    def ChangeConditionParamsX(*args): return apply(_pyIFC.CImmCondition_ChangeConditionParamsX,args)
    def ChangeConditionParamsPolarX(*args): return apply(_pyIFC.CImmCondition_ChangeConditionParamsPolarX,args)
    def ChangeConditionParamsY(*args): return apply(_pyIFC.CImmCondition_ChangeConditionParamsY,args)
    def ChangeConditionParamsPolarY(*args): return apply(_pyIFC.CImmCondition_ChangeConditionParamsPolarY,args)
    def ChangeConditionParams(*args): return apply(_pyIFC.CImmCondition_ChangeConditionParams,args)
    def ChangeConditionParamsPolar(*args): return apply(_pyIFC.CImmCondition_ChangeConditionParamsPolar,args)
    def ChangePositiveCoefficientX(*args): return apply(_pyIFC.CImmCondition_ChangePositiveCoefficientX,args)
    def ChangeNegativeCoefficientX(*args): return apply(_pyIFC.CImmCondition_ChangeNegativeCoefficientX,args)
    def ChangePositiveSaturationX(*args): return apply(_pyIFC.CImmCondition_ChangePositiveSaturationX,args)
    def ChangeNegativeSaturationX(*args): return apply(_pyIFC.CImmCondition_ChangeNegativeSaturationX,args)
    def ChangeDeadBandX(*args): return apply(_pyIFC.CImmCondition_ChangeDeadBandX,args)
    def ChangePositiveCoefficientY(*args): return apply(_pyIFC.CImmCondition_ChangePositiveCoefficientY,args)
    def ChangeNegativeCoefficientY(*args): return apply(_pyIFC.CImmCondition_ChangeNegativeCoefficientY,args)
    def ChangePositiveSaturationY(*args): return apply(_pyIFC.CImmCondition_ChangePositiveSaturationY,args)
    def ChangeNegativeSaturationY(*args): return apply(_pyIFC.CImmCondition_ChangeNegativeSaturationY,args)
    def ChangeDeadBandY(*args): return apply(_pyIFC.CImmCondition_ChangeDeadBandY,args)
    def ChangePositiveCoefficient(*args): return apply(_pyIFC.CImmCondition_ChangePositiveCoefficient,args)
    def ChangeNegativeCoefficient(*args): return apply(_pyIFC.CImmCondition_ChangeNegativeCoefficient,args)
    def ChangePositiveSaturation(*args): return apply(_pyIFC.CImmCondition_ChangePositiveSaturation,args)
    def ChangeNegativeSaturation(*args): return apply(_pyIFC.CImmCondition_ChangeNegativeSaturation,args)
    def ChangeDeadBand(*args): return apply(_pyIFC.CImmCondition_ChangeDeadBand,args)
    def ChangeCenter(*args): return apply(_pyIFC.CImmCondition_ChangeCenter,args)
    def GetPositiveCoefficientX(*args): return apply(_pyIFC.CImmCondition_GetPositiveCoefficientX,args)
    def GetNegativeCoefficientX(*args): return apply(_pyIFC.CImmCondition_GetNegativeCoefficientX,args)
    def GetPositiveSaturationX(*args): return apply(_pyIFC.CImmCondition_GetPositiveSaturationX,args)
    def GetNegativeSaturationX(*args): return apply(_pyIFC.CImmCondition_GetNegativeSaturationX,args)
    def GetDeadBandX(*args): return apply(_pyIFC.CImmCondition_GetDeadBandX,args)
    def GetPositiveCoefficientY(*args): return apply(_pyIFC.CImmCondition_GetPositiveCoefficientY,args)
    def GetNegativeCoefficientY(*args): return apply(_pyIFC.CImmCondition_GetNegativeCoefficientY,args)
    def GetPositiveSaturationY(*args): return apply(_pyIFC.CImmCondition_GetPositiveSaturationY,args)
    def GetNegativeSaturationY(*args): return apply(_pyIFC.CImmCondition_GetNegativeSaturationY,args)
    def GetDeadBandY(*args): return apply(_pyIFC.CImmCondition_GetDeadBandY,args)
    def GetAxis(*args): return apply(_pyIFC.CImmCondition_GetAxis,args)
    def GetCenter(*args): return apply(_pyIFC.CImmCondition_GetCenter,args)
    def InitCondition(*args): return apply(_pyIFC.CImmCondition_InitCondition,args)
    def InitConditionPolar(*args): return apply(_pyIFC.CImmCondition_InitConditionPolar,args)
    def Start(*args): return apply(_pyIFC.CImmCondition_Start,args)
    def __repr__(self):
        return "<C CImmCondition instance at %s>" % (self.this,)

class CImmConditionPtr(CImmCondition):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmCondition
_pyIFC.CImmCondition_swigregister(CImmConditionPtr)

class CImmEnclosure(CImmEffect):
    __swig_setmethods__ = {}
    for _s in [CImmEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmEnclosure, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmEnclosure, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmEnclosure,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmEnclosure):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmEnclosure_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmEnclosure_GetEffectType,args)
    def ChangeParametersPoint(*args): return apply(_pyIFC.CImmEnclosure_ChangeParametersPoint,args)
    def ChangeParametersRect(*args): return apply(_pyIFC.CImmEnclosure_ChangeParametersRect,args)
    def ChangeTopAndBottomWallStiffness(*args): return apply(_pyIFC.CImmEnclosure_ChangeTopAndBottomWallStiffness,args)
    def ChangeLeftAndRightWallStiffness(*args): return apply(_pyIFC.CImmEnclosure_ChangeLeftAndRightWallStiffness,args)
    def ChangeTopAndBottomWallThickness(*args): return apply(_pyIFC.CImmEnclosure_ChangeTopAndBottomWallThickness,args)
    def ChangeLeftAndRightWallThickness(*args): return apply(_pyIFC.CImmEnclosure_ChangeLeftAndRightWallThickness,args)
    def ChangeTopAndBottomWallSaturation(*args): return apply(_pyIFC.CImmEnclosure_ChangeTopAndBottomWallSaturation,args)
    def ChangeLeftAndRightWallSaturation(*args): return apply(_pyIFC.CImmEnclosure_ChangeLeftAndRightWallSaturation,args)
    def ChangeStiffnessMask(*args): return apply(_pyIFC.CImmEnclosure_ChangeStiffnessMask,args)
    def ChangeClippingMask(*args): return apply(_pyIFC.CImmEnclosure_ChangeClippingMask,args)
    def ChangeInsideEffect(*args): return apply(_pyIFC.CImmEnclosure_ChangeInsideEffect,args)
    def ChangeRect(*args): return apply(_pyIFC.CImmEnclosure_ChangeRect,args)
    def ChangeCenterPoint(*args): return apply(_pyIFC.CImmEnclosure_ChangeCenterPoint,args)
    def ChangeCenterXY(*args): return apply(_pyIFC.CImmEnclosure_ChangeCenterXY,args)
    def ShowRect(*args): return apply(_pyIFC.CImmEnclosure_ShowRect,args)
    def GetTopAndBottomWallStiffness(*args): return apply(_pyIFC.CImmEnclosure_GetTopAndBottomWallStiffness,args)
    def GetLeftAndRightWallStiffness(*args): return apply(_pyIFC.CImmEnclosure_GetLeftAndRightWallStiffness,args)
    def GetTopAndBottomWallThickness(*args): return apply(_pyIFC.CImmEnclosure_GetTopAndBottomWallThickness,args)
    def GetLeftAndRightWallThickness(*args): return apply(_pyIFC.CImmEnclosure_GetLeftAndRightWallThickness,args)
    def GetTopAndBottomWallSaturation(*args): return apply(_pyIFC.CImmEnclosure_GetTopAndBottomWallSaturation,args)
    def GetLeftAndRightWallSaturation(*args): return apply(_pyIFC.CImmEnclosure_GetLeftAndRightWallSaturation,args)
    def GetStiffnessMask(*args): return apply(_pyIFC.CImmEnclosure_GetStiffnessMask,args)
    def GetClippingMask(*args): return apply(_pyIFC.CImmEnclosure_GetClippingMask,args)
    def GetRect(*args): return apply(_pyIFC.CImmEnclosure_GetRect,args)
    def GetCenterPoint(*args): return apply(_pyIFC.CImmEnclosure_GetCenterPoint,args)
    def GetCenterXY(*args): return apply(_pyIFC.CImmEnclosure_GetCenterXY,args)
    def GetInsideEffect(*args): return apply(_pyIFC.CImmEnclosure_GetInsideEffect,args)
    def Initialize(*args): return apply(_pyIFC.CImmEnclosure_Initialize,args)
    def InitializePoint(*args): return apply(_pyIFC.CImmEnclosure_InitializePoint,args)
    def InitializeRect(*args): return apply(_pyIFC.CImmEnclosure_InitializeRect,args)
    def Start(*args): return apply(_pyIFC.CImmEnclosure_Start,args)
    def Stop(*args): return apply(_pyIFC.CImmEnclosure_Stop,args)
    def Unload(*args): return apply(_pyIFC.CImmEnclosure_Unload,args)
    def Reload(*args): return apply(_pyIFC.CImmEnclosure_Reload,args)
    def __repr__(self):
        return "<C CImmEnclosure instance at %s>" % (self.this,)

class CImmEnclosurePtr(CImmEnclosure):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmEnclosure
_pyIFC.CImmEnclosure_swigregister(CImmEnclosurePtr)

class CImmBox(CImmEnclosure):
    __swig_setmethods__ = {}
    for _s in [CImmEnclosure]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmBox, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEnclosure]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmBox, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmBox,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmBox):
        try:
            if self.thisown: destroy(self)
        except: pass
    def ChangeParametersPoint(*args): return apply(_pyIFC.CImmBox_ChangeParametersPoint,args)
    def ChangeParametersRect(*args): return apply(_pyIFC.CImmBox_ChangeParametersRect,args)
    def InitializePoint(*args): return apply(_pyIFC.CImmBox_InitializePoint,args)
    def InitializeRect(*args): return apply(_pyIFC.CImmBox_InitializeRect,args)
    def __repr__(self):
        return "<C CImmBox instance at %s>" % (self.this,)

class CImmBoxPtr(CImmBox):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmBox
_pyIFC.CImmBox_swigregister(CImmBoxPtr)

class CImmEllipse(CImmEffect):
    __swig_setmethods__ = {}
    for _s in [CImmEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmEllipse, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmEllipse, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmEllipse,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmEllipse):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmEllipse_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmEllipse_GetEffectType,args)
    def ChangeParametersPoint(*args): return apply(_pyIFC.CImmEllipse_ChangeParametersPoint,args)
    def ChangeParametersRect(*args): return apply(_pyIFC.CImmEllipse_ChangeParametersRect,args)
    def ChangeStiffness(*args): return apply(_pyIFC.CImmEllipse_ChangeStiffness,args)
    def ChangeWallThickness(*args): return apply(_pyIFC.CImmEllipse_ChangeWallThickness,args)
    def ChangeSaturation(*args): return apply(_pyIFC.CImmEllipse_ChangeSaturation,args)
    def ChangeStiffnessMask(*args): return apply(_pyIFC.CImmEllipse_ChangeStiffnessMask,args)
    def ChangeClippingMask(*args): return apply(_pyIFC.CImmEllipse_ChangeClippingMask,args)
    def ChangeInsideEffect(*args): return apply(_pyIFC.CImmEllipse_ChangeInsideEffect,args)
    def ChangeRect(*args): return apply(_pyIFC.CImmEllipse_ChangeRect,args)
    def ChangeCenterPoint(*args): return apply(_pyIFC.CImmEllipse_ChangeCenterPoint,args)
    def ChangeCenterXY(*args): return apply(_pyIFC.CImmEllipse_ChangeCenterXY,args)
    def GetStiffness(*args): return apply(_pyIFC.CImmEllipse_GetStiffness,args)
    def GetWallThickness(*args): return apply(_pyIFC.CImmEllipse_GetWallThickness,args)
    def GetSaturation(*args): return apply(_pyIFC.CImmEllipse_GetSaturation,args)
    def GetStiffnessMask(*args): return apply(_pyIFC.CImmEllipse_GetStiffnessMask,args)
    def GetClippingMask(*args): return apply(_pyIFC.CImmEllipse_GetClippingMask,args)
    def GetRect(*args): return apply(_pyIFC.CImmEllipse_GetRect,args)
    def GetCenterPoint(*args): return apply(_pyIFC.CImmEllipse_GetCenterPoint,args)
    def GetCenterXY(*args): return apply(_pyIFC.CImmEllipse_GetCenterXY,args)
    def GetInsideEffect(*args): return apply(_pyIFC.CImmEllipse_GetInsideEffect,args)
    def Initialize(*args): return apply(_pyIFC.CImmEllipse_Initialize,args)
    def InitializePoint(*args): return apply(_pyIFC.CImmEllipse_InitializePoint,args)
    def InitializeRect(*args): return apply(_pyIFC.CImmEllipse_InitializeRect,args)
    def Start(*args): return apply(_pyIFC.CImmEllipse_Start,args)
    def Unload(*args): return apply(_pyIFC.CImmEllipse_Unload,args)
    def Reload(*args): return apply(_pyIFC.CImmEllipse_Reload,args)
    def __repr__(self):
        return "<C CImmEllipse instance at %s>" % (self.this,)

class CImmEllipsePtr(CImmEllipse):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmEllipse
_pyIFC.CImmEllipse_swigregister(CImmEllipsePtr)

class CImmConstant(CImmEffect):
    __swig_setmethods__ = {}
    for _s in [CImmEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmConstant, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmConstant, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmConstant,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmConstant):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmConstant_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmConstant_GetEffectType,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmConstant_ChangeParameters,args)
    def ChangeParametersPolar(*args): return apply(_pyIFC.CImmConstant_ChangeParametersPolar,args)
    def ChangeMagnitude(*args): return apply(_pyIFC.CImmConstant_ChangeMagnitude,args)
    def GetMagnitude(*args): return apply(_pyIFC.CImmConstant_GetMagnitude,args)
    def Initialize(*args): return apply(_pyIFC.CImmConstant_Initialize,args)
    def InitializePolar(*args): return apply(_pyIFC.CImmConstant_InitializePolar,args)
    def __repr__(self):
        return "<C CImmConstant instance at %s>" % (self.this,)

class CImmConstantPtr(CImmConstant):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmConstant
_pyIFC.CImmConstant_swigregister(CImmConstantPtr)

class CImmDamper(CImmCondition):
    __swig_setmethods__ = {}
    for _s in [CImmCondition]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmDamper, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmCondition]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmDamper, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmDamper,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmDamper):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmDamper_GetIsCompatibleGUID,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmDamper_ChangeParameters,args)
    def ChangeParametersPolar(*args): return apply(_pyIFC.CImmDamper_ChangeParametersPolar,args)
    def ChangeViscosity(*args): return apply(_pyIFC.CImmDamper_ChangeViscosity,args)
    def ChangeMinVelocityX(*args): return apply(_pyIFC.CImmDamper_ChangeMinVelocityX,args)
    def ChangeMinVelocityY(*args): return apply(_pyIFC.CImmDamper_ChangeMinVelocityY,args)
    def ChangeMinVelocity(*args): return apply(_pyIFC.CImmDamper_ChangeMinVelocity,args)
    def GetViscosity(*args): return apply(_pyIFC.CImmDamper_GetViscosity,args)
    def GetMinVelocityX(*args): return apply(_pyIFC.CImmDamper_GetMinVelocityX,args)
    def GetMinVelocityY(*args): return apply(_pyIFC.CImmDamper_GetMinVelocityY,args)
    def Initialize(*args): return apply(_pyIFC.CImmDamper_Initialize,args)
    def InitializePolar(*args): return apply(_pyIFC.CImmDamper_InitializePolar,args)
    def __repr__(self):
        return "<C CImmDamper instance at %s>" % (self.this,)

class CImmDamperPtr(CImmDamper):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmDamper
_pyIFC.CImmDamper_swigregister(CImmDamperPtr)

class CImmFriction(CImmCondition):
    __swig_setmethods__ = {}
    for _s in [CImmCondition]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmFriction, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmCondition]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmFriction, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmFriction,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmFriction):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmFriction_GetIsCompatibleGUID,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmFriction_ChangeParameters,args)
    def ChangeParametersPolar(*args): return apply(_pyIFC.CImmFriction_ChangeParametersPolar,args)
    def ChangeMinVelocityX(*args): return apply(_pyIFC.CImmFriction_ChangeMinVelocityX,args)
    def ChangeMinVelocityY(*args): return apply(_pyIFC.CImmFriction_ChangeMinVelocityY,args)
    def ChangeMinVelocity(*args): return apply(_pyIFC.CImmFriction_ChangeMinVelocity,args)
    def GetMinVelocityX(*args): return apply(_pyIFC.CImmFriction_GetMinVelocityX,args)
    def GetMinVelocityY(*args): return apply(_pyIFC.CImmFriction_GetMinVelocityY,args)
    def Initialize(*args): return apply(_pyIFC.CImmFriction_Initialize,args)
    def InitializePolar(*args): return apply(_pyIFC.CImmFriction_InitializePolar,args)
    def __repr__(self):
        return "<C CImmFriction instance at %s>" % (self.this,)

class CImmFrictionPtr(CImmFriction):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmFriction
_pyIFC.CImmFriction_swigregister(CImmFrictionPtr)

class CImmGrid(CImmCondition):
    __swig_setmethods__ = {}
    for _s in [CImmCondition]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmGrid, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmCondition]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmGrid, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmGrid,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmGrid):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmGrid_GetIsCompatibleGUID,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmGrid_ChangeParameters,args)
    def ChangeHSpacing(*args): return apply(_pyIFC.CImmGrid_ChangeHSpacing,args)
    def ChangeVSpacing(*args): return apply(_pyIFC.CImmGrid_ChangeVSpacing,args)
    def ChangeHNodeStrength(*args): return apply(_pyIFC.CImmGrid_ChangeHNodeStrength,args)
    def ChangeVNodeStrength(*args): return apply(_pyIFC.CImmGrid_ChangeVNodeStrength,args)
    def ChangeOffset(*args): return apply(_pyIFC.CImmGrid_ChangeOffset,args)
    def ChangeHNodeSaturation(*args): return apply(_pyIFC.CImmGrid_ChangeHNodeSaturation,args)
    def ChangeVNodeSaturation(*args): return apply(_pyIFC.CImmGrid_ChangeVNodeSaturation,args)
    def GetHSpacing(*args): return apply(_pyIFC.CImmGrid_GetHSpacing,args)
    def GetVSpacing(*args): return apply(_pyIFC.CImmGrid_GetVSpacing,args)
    def GetHNodeStrength(*args): return apply(_pyIFC.CImmGrid_GetHNodeStrength,args)
    def GetVNodeStrength(*args): return apply(_pyIFC.CImmGrid_GetVNodeStrength,args)
    def GetOffset(*args): return apply(_pyIFC.CImmGrid_GetOffset,args)
    def GetHNodeSaturation(*args): return apply(_pyIFC.CImmGrid_GetHNodeSaturation,args)
    def GetVNodeSaturation(*args): return apply(_pyIFC.CImmGrid_GetVNodeSaturation,args)
    def Initialize(*args): return apply(_pyIFC.CImmGrid_Initialize,args)
    def __repr__(self):
        return "<C CImmGrid instance at %s>" % (self.this,)

class CImmGridPtr(CImmGrid):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmGrid
_pyIFC.CImmGrid_swigregister(CImmGridPtr)

class CImmInertia(CImmCondition):
    __swig_setmethods__ = {}
    for _s in [CImmCondition]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmInertia, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmCondition]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmInertia, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmInertia,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmInertia):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmInertia_GetIsCompatibleGUID,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmInertia_ChangeParameters,args)
    def ChangeParametersPolar(*args): return apply(_pyIFC.CImmInertia_ChangeParametersPolar,args)
    def ChangeMinAccelerationX(*args): return apply(_pyIFC.CImmInertia_ChangeMinAccelerationX,args)
    def ChangeMinAccelerationY(*args): return apply(_pyIFC.CImmInertia_ChangeMinAccelerationY,args)
    def ChangeMinAcceleration(*args): return apply(_pyIFC.CImmInertia_ChangeMinAcceleration,args)
    def GetMinAccelerationX(*args): return apply(_pyIFC.CImmInertia_GetMinAccelerationX,args)
    def GetMinAccelerationY(*args): return apply(_pyIFC.CImmInertia_GetMinAccelerationY,args)
    def Initialize(*args): return apply(_pyIFC.CImmInertia_Initialize,args)
    def InitializePolar(*args): return apply(_pyIFC.CImmInertia_InitializePolar,args)
    def __repr__(self):
        return "<C CImmInertia instance at %s>" % (self.this,)

class CImmInertiaPtr(CImmInertia):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmInertia
_pyIFC.CImmInertia_swigregister(CImmInertiaPtr)

class CImmPeriodic(CImmEffect):
    __swig_setmethods__ = {}
    for _s in [CImmEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmPeriodic, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmPeriodic, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmPeriodic,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmPeriodic):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmPeriodic_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmPeriodic_GetEffectType,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmPeriodic_ChangeParameters,args)
    def ChangeParametersPolar(*args): return apply(_pyIFC.CImmPeriodic_ChangeParametersPolar,args)
    def ChangeMagnitude(*args): return apply(_pyIFC.CImmPeriodic_ChangeMagnitude,args)
    def ChangePeriod(*args): return apply(_pyIFC.CImmPeriodic_ChangePeriod,args)
    def ChangeOffset(*args): return apply(_pyIFC.CImmPeriodic_ChangeOffset,args)
    def ChangePhase(*args): return apply(_pyIFC.CImmPeriodic_ChangePhase,args)
    def GetMagnitude(*args): return apply(_pyIFC.CImmPeriodic_GetMagnitude,args)
    def GetPeriod(*args): return apply(_pyIFC.CImmPeriodic_GetPeriod,args)
    def GetOffset(*args): return apply(_pyIFC.CImmPeriodic_GetOffset,args)
    def GetPhase(*args): return apply(_pyIFC.CImmPeriodic_GetPhase,args)
    def Initialize(*args): return apply(_pyIFC.CImmPeriodic_Initialize,args)
    def InitializePolar(*args): return apply(_pyIFC.CImmPeriodic_InitializePolar,args)
    def __repr__(self):
        return "<C CImmPeriodic instance at %s>" % (self.this,)

class CImmPeriodicPtr(CImmPeriodic):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmPeriodic
_pyIFC.CImmPeriodic_swigregister(CImmPeriodicPtr)
def CImmPeriodicFromGUID(*args):
    val = apply(_pyIFC.new_CImmPeriodicFromGUID,args)
    val.thisown = 1
    return val


class CImmSpring(CImmCondition):
    __swig_setmethods__ = {}
    for _s in [CImmCondition]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmSpring, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmCondition]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmSpring, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmSpring,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmSpring):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmSpring_GetIsCompatibleGUID,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmSpring_ChangeParameters,args)
    def ChangeParametersPolar(*args): return apply(_pyIFC.CImmSpring_ChangeParametersPolar,args)
    def Initialize(*args): return apply(_pyIFC.CImmSpring_Initialize,args)
    def InitializePolar(*args): return apply(_pyIFC.CImmSpring_InitializePolar,args)
    def __repr__(self):
        return "<C CImmSpring instance at %s>" % (self.this,)

class CImmSpringPtr(CImmSpring):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmSpring
_pyIFC.CImmSpring_swigregister(CImmSpringPtr)

class CImmRamp(CImmEffect):
    __swig_setmethods__ = {}
    for _s in [CImmEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmRamp, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmRamp, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmRamp,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmRamp):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmRamp_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmRamp_GetEffectType,args)
    def ChangeParameters(*args): return apply(_pyIFC.CImmRamp_ChangeParameters,args)
    def ChangeParametersPolar(*args): return apply(_pyIFC.CImmRamp_ChangeParametersPolar,args)
    def ChangeStartMagnitude(*args): return apply(_pyIFC.CImmRamp_ChangeStartMagnitude,args)
    def ChangeEndMagnitude(*args): return apply(_pyIFC.CImmRamp_ChangeEndMagnitude,args)
    def GetStartMagnitude(*args): return apply(_pyIFC.CImmRamp_GetStartMagnitude,args)
    def GetEndMagnitude(*args): return apply(_pyIFC.CImmRamp_GetEndMagnitude,args)
    def Initialize(*args): return apply(_pyIFC.CImmRamp_Initialize,args)
    def InitializePolar(*args): return apply(_pyIFC.CImmRamp_InitializePolar,args)
    def __repr__(self):
        return "<C CImmRamp instance at %s>" % (self.this,)

class CImmRampPtr(CImmRamp):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmRamp
_pyIFC.CImmRamp_swigregister(CImmRampPtr)

class CImmTexture(CImmEffect):
    __swig_setmethods__ = {}
    for _s in [CImmEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmTexture, name, value)
    __swig_getmethods__ = {}
    for _s in [CImmEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, CImmTexture, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmTexture,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmTexture):
        try:
            if self.thisown: destroy(self)
        except: pass
    def GetIsCompatibleGUID(*args): return apply(_pyIFC.CImmTexture_GetIsCompatibleGUID,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmTexture_GetEffectType,args)
    def ChangeTextureParams(*args): return apply(_pyIFC.CImmTexture_ChangeTextureParams,args)
    def ChangeTextureParamsX(*args): return apply(_pyIFC.CImmTexture_ChangeTextureParamsX,args)
    def ChangeTextureParamsY(*args): return apply(_pyIFC.CImmTexture_ChangeTextureParamsY,args)
    def ChangeTextureParamsPolar(*args): return apply(_pyIFC.CImmTexture_ChangeTextureParamsPolar,args)
    def ChangeTextureParamsPolarX(*args): return apply(_pyIFC.CImmTexture_ChangeTextureParamsPolarX,args)
    def ChangeTextureParamsPolarY(*args): return apply(_pyIFC.CImmTexture_ChangeTextureParamsPolarY,args)
    def ChangePositiveBumpMagX(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpMagX,args)
    def ChangeNegativeBumpMagX(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpMagX,args)
    def ChangePositiveBumpSpacingX(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpSpacingX,args)
    def ChangeNegativeBumpSpacingX(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpSpacingX,args)
    def ChangePositiveBumpWidthX(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpWidthX,args)
    def ChangeNegativeBumpWidthX(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpWidthX,args)
    def ChangePositiveBumpMagY(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpMagY,args)
    def ChangeNegativeBumpMagY(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpMagY,args)
    def ChangePositiveBumpSpacingY(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpSpacingY,args)
    def ChangeNegativeBumpSpacingY(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpSpacingY,args)
    def ChangePositiveBumpWidthY(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpWidthY,args)
    def ChangeNegativeBumpWidthY(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpWidthY,args)
    def ChangePositiveBumpMag(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpMag,args)
    def ChangeNegativeBumpMag(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpMag,args)
    def ChangePositiveBumpSpacing(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpSpacing,args)
    def ChangeNegativeBumpSpacing(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpSpacing,args)
    def ChangePositiveBumpWidth(*args): return apply(_pyIFC.CImmTexture_ChangePositiveBumpWidth,args)
    def ChangeNegativeBumpWidth(*args): return apply(_pyIFC.CImmTexture_ChangeNegativeBumpWidth,args)
    def ChangeOffset(*args): return apply(_pyIFC.CImmTexture_ChangeOffset,args)
    def GetPositiveBumpMagX(*args): return apply(_pyIFC.CImmTexture_GetPositiveBumpMagX,args)
    def GetNegativeBumpMagX(*args): return apply(_pyIFC.CImmTexture_GetNegativeBumpMagX,args)
    def GetPositiveBumpSpacingX(*args): return apply(_pyIFC.CImmTexture_GetPositiveBumpSpacingX,args)
    def GetNegativeBumpSpacingX(*args): return apply(_pyIFC.CImmTexture_GetNegativeBumpSpacingX,args)
    def GetPositiveBumpWidthX(*args): return apply(_pyIFC.CImmTexture_GetPositiveBumpWidthX,args)
    def GetNegativeBumpWidthX(*args): return apply(_pyIFC.CImmTexture_GetNegativeBumpWidthX,args)
    def GetPositiveBumpMagY(*args): return apply(_pyIFC.CImmTexture_GetPositiveBumpMagY,args)
    def GetNegativeBumpMagY(*args): return apply(_pyIFC.CImmTexture_GetNegativeBumpMagY,args)
    def GetPositiveBumpSpacingY(*args): return apply(_pyIFC.CImmTexture_GetPositiveBumpSpacingY,args)
    def GetNegativeBumpSpacingY(*args): return apply(_pyIFC.CImmTexture_GetNegativeBumpSpacingY,args)
    def GetPositiveBumpWidthY(*args): return apply(_pyIFC.CImmTexture_GetPositiveBumpWidthY,args)
    def GetNegativeBumpWidthY(*args): return apply(_pyIFC.CImmTexture_GetNegativeBumpWidthY,args)
    def GetOffset(*args): return apply(_pyIFC.CImmTexture_GetOffset,args)
    def InitTexture(*args): return apply(_pyIFC.CImmTexture_InitTexture,args)
    def InitTexturePolar(*args): return apply(_pyIFC.CImmTexture_InitTexturePolar,args)
    def __repr__(self):
        return "<C CImmTexture instance at %s>" % (self.this,)

class CImmTexturePtr(CImmTexture):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmTexture
_pyIFC.CImmTexture_swigregister(CImmTexturePtr)

class CImmProject(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmProject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CImmProject, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmProject,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmProject):
        try:
            if self.thisown: destroy(self)
        except: pass
    def Close(*args): return apply(_pyIFC.CImmProject_Close,args)
    def GetDevice(*args): return apply(_pyIFC.CImmProject_GetDevice,args)
    def GetIsOpen(*args): return apply(_pyIFC.CImmProject_GetIsOpen,args)
    def GetEffect(*args): return apply(_pyIFC.CImmProject_GetEffect,args)
    def GetEffectFromIndex(*args): return apply(_pyIFC.CImmProject_GetEffectFromIndex,args)
    def GetNumEffects(*args): return apply(_pyIFC.CImmProject_GetNumEffects,args)
    def GetNumSounds(*args): return apply(_pyIFC.CImmProject_GetNumSounds,args)
    def GetEffectName(*args): return apply(_pyIFC.CImmProject_GetEffectName,args)
    def GetSoundName(*args): return apply(_pyIFC.CImmProject_GetSoundName,args)
    def GetSoundPath(*args): return apply(_pyIFC.CImmProject_GetSoundPath,args)
    def GetSoundData(*args): return apply(_pyIFC.CImmProject_GetSoundData,args)
    def GetEffectType(*args): return apply(_pyIFC.CImmProject_GetEffectType,args)
    def GetEffectTypeIndex(*args): return apply(_pyIFC.CImmProject_GetEffectTypeIndex,args)
    def GetTypeName(*args): return apply(_pyIFC.CImmProject_GetTypeName,args)
    def GetTypeNameIndex(*args): return apply(_pyIFC.CImmProject_GetTypeNameIndex,args)
    def Start(*args): return apply(_pyIFC.CImmProject_Start,args)
    def Stop(*args): return apply(_pyIFC.CImmProject_Stop,args)
    def OpenFile(*args): return apply(_pyIFC.CImmProject_OpenFile,args)
    def LoadProjectFromResource(*args): return apply(_pyIFC.CImmProject_LoadProjectFromResource,args)
    def LoadProjectFromMemory(*args): return apply(_pyIFC.CImmProject_LoadProjectFromMemory,args)
    def LoadProjectObjectPointer(*args): return apply(_pyIFC.CImmProject_LoadProjectObjectPointer,args)
    def WriteToFile(*args): return apply(_pyIFC.CImmProject_WriteToFile,args)
    def CreateEffect(*args): return apply(_pyIFC.CImmProject_CreateEffect,args)
    def CreateEffectByIndex(*args): return apply(_pyIFC.CImmProject_CreateEffectByIndex,args)
    def AddEffect(*args): return apply(_pyIFC.CImmProject_AddEffect,args)
    def AddSoundInfo(*args): return apply(_pyIFC.CImmProject_AddSoundInfo,args)
    def CreateCompound(*args): return apply(_pyIFC.CImmProject_CreateCompound,args)
    def AddToCompound(*args): return apply(_pyIFC.CImmProject_AddToCompound,args)
    def RemoveFromCompound(*args): return apply(_pyIFC.CImmProject_RemoveFromCompound,args)
    def RemoveSound(*args): return apply(_pyIFC.CImmProject_RemoveSound,args)
    def RemoveEffect(*args): return apply(_pyIFC.CImmProject_RemoveEffect,args)
    def DestroyEffect(*args): return apply(_pyIFC.CImmProject_DestroyEffect,args)
    def __repr__(self):
        return "<C CImmProject instance at %s>" % (self.this,)

class CImmProjectPtr(CImmProject):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmProject
_pyIFC.CImmProject_swigregister(CImmProjectPtr)

class CImmProjects(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CImmProjects, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CImmProjects, name)
    def __init__(self,*args):
        self.this = apply(_pyIFC.new_CImmProjects,args)
        self.thisown = 1
    def __del__(self, destroy= _pyIFC.delete_CImmProjects):
        try:
            if self.thisown: destroy(self)
        except: pass
    def Close(*args): return apply(_pyIFC.CImmProjects_Close,args)
    def GetProject(*args): return apply(_pyIFC.CImmProjects_GetProject,args)
    def Stop(*args): return apply(_pyIFC.CImmProjects_Stop,args)
    def OpenFile(*args): return apply(_pyIFC.CImmProjects_OpenFile,args)
    def LoadProjectFromResource(*args): return apply(_pyIFC.CImmProjects_LoadProjectFromResource,args)
    def LoadProjectFromMemory(*args): return apply(_pyIFC.CImmProjects_LoadProjectFromMemory,args)
    def __repr__(self):
        return "<C CImmProjects instance at %s>" % (self.this,)

class CImmProjectsPtr(CImmProjects):
    def __init__(self,this):
        self.this = this
        if not hasattr(self,"thisown"): self.thisown = 0
        self.__class__ = CImmProjects
_pyIFC.CImmProjects_swigregister(CImmProjectsPtr)

class pyImmProject(CImmProject):
	def Start(self,
		effect,
		iter = IMM_EFFECT_DONT_CHANGE,
		flags = 0,
		dev = None):
		self.effect_playing = effect
		return CImmProject.Start(self, effect, iter, flags, dev)
		
	def Stop(self, effect = None):
		if effect == None:
			try:
				return CImmProject.Stop(self, self.effect_playing)
				self.effect_playing = None
			except:
				return 0
		else:
			return CImmProject.Stop(self, effect)


class pyImmEnclosure(CImmEnclosure):
	def ChangeParametersPoint(self,
		center,
		width = IMM_EFFECT_DONT_CHANGE,
		height = IMM_EFFECT_DONT_CHANGE,
		tbStiff= IMM_EFFECT_DONT_CHANGE,
		lrStiff = IMM_EFFECT_DONT_CHANGE,
		tbWidth = IMM_EFFECT_DONT_CHANGE,
		lrWidth = IMM_EFFECT_DONT_CHANGE,
		tbSat = IMM_EFFECT_DONT_CHANGE,
		lrSat = IMM_EFFECT_DONT_CHANGE,
		stiffMask = IMM_EFFECT_DONT_CHANGE,
		clipMask = IMM_EFFECT_DONT_CHANGE,
		insideEffect = IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT,
		angle = IMM_EFFECT_DONT_CHANGE
		):
		return CImmEnclosure.ChangeParametersPoint(self, center,
			width, height, tbStiff, lrStiff, tbWidth, lrWidth,
			tbSat, lrSat, stiffMask, clipMask, insideEffect,
			angle)
	def ChangeParametersRect(self,
		rect,
		tbStiff= IMM_EFFECT_DONT_CHANGE,
		lrStiff = IMM_EFFECT_DONT_CHANGE,
		tbWidth = IMM_EFFECT_DONT_CHANGE,
		lrWidth = IMM_EFFECT_DONT_CHANGE,
		tbSat = IMM_EFFECT_DONT_CHANGE,
		lrSat = IMM_EFFECT_DONT_CHANGE,
		stiffMask = IMM_EFFECT_DONT_CHANGE,
		clipMask = IMM_EFFECT_DONT_CHANGE,
		insideEffect = IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT,
		angle = IMM_EFFECT_DONT_CHANGE
		):
		return CImmEnclosure.ChangeParametersRect(self, rect,
			tbStiff, lrStiff, tbWidth, lrWidth,	tbSat, lrSat,
			stiffMask, clipMask, insideEffect, angle)
			
	def InitializePoint(self,
		device,
		center,
		width = IMM_ENCLOSURE_DEFAULT_WIDTH,
		height = IMM_ENCLOSURE_DEFAULT_HEIGHT,
		tbStiff= IMM_ENCLOSURE_DEFAULT_STIFFNESS,
		lrStiff = IMM_ENCLOSURE_DEFAULT_STIFFNESS,
		tbWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
		lrWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
		tbSat = IMM_ENCLOSURE_DEFAULT_SATURATION,
		lrSat = IMM_ENCLOSURE_DEFAULT_SATURATION,
		stiffMask = IMM_ENCLOSURE_DEFAULT_STIFFNESS_MASK,
		clipMask = IMM_ENCLOSURE_DEFAULT_CLIPPING_MASK,
		insideEffect = None,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
		
		return CImmEnclosure.InitializePoint(self, device,
			width, height, tbStiff, lrStiff, tbWidth, lrWidth,
			tbSat, lrSat, stiffMask, clipMask, center, insideEffect,
			angle, noDownload)
	
	def InitializeRect(self,
		device,
		rect,
		tbStiff = IMM_ENCLOSURE_DEFAULT_STIFFNESS,
		lrStiff = IMM_ENCLOSURE_DEFAULT_STIFFNESS,
		tbWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
		lrWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
		tbSat = IMM_ENCLOSURE_DEFAULT_SATURATION,
		lrSat = IMM_ENCLOSURE_DEFAULT_SATURATION,
		stiffMask = IMM_ENCLOSURE_DEFAULT_STIFFNESS_MASK,
		clipMask = IMM_ENCLOSURE_DEFAULT_CLIPPING_MASK,
		insideEffect = None,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
		return CImmEnclosure.InitializeRect(self, device, rect, tbStiff,
			lrStiff, tbWidth, lrWidth, tbSat, lrSat, stiffMask, clipMask,
			insideEffect, angle, noDownload)


class pyImmBox(CImmBox):
	def ChangeParametersPoint(self,
		center,
		stiff = IMM_EFFECT_DONT_CHANGE,
		width = IMM_EFFECT_DONT_CHANGE,
		height = IMM_EFFECT_DONT_CHANGE,
		wallWidth = IMM_EFFECT_DONT_CHANGE,
		insideEffect = IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT):
	
		return CImmBox.ChangeParametersPoint(self, center, stiff,
			width, height, wallWidth, insideEffect)
				
	def ChangeParametersRect(self,
		rect,
		stiff = IMM_EFFECT_DONT_CHANGE,
		wallWidth = IMM_EFFECT_DONT_CHANGE,
		insideEffect = IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT):
		
		return CImmBox.ChangeParametersRect(self, rect, stiff,
			wallWidth, insideEffect)
				
	def InitializePoint(self,
		device,
		center,
		width = IMM_ENCLOSURE_DEFAULT_WIDTH,
		height = IMM_ENCLOSURE_DEFAULT_HEIGHT,
		stiff = IMM_BOX_DEFAULT_STIFFNESS,
		wallWidth = IMM_BOX_DEFAULT_WALL_WIDTH,
		insideEffect = None,
		noDownload = 0):
		
		return CImmBox.InitializePoint(self, device, width, height,
			stiff, wallWidth, center, insideEffect, noDownload)
	
	def InitializeRect(self,
		device,
		rect,
		stiff = IMM_BOX_DEFAULT_STIFFNESS,
		wallWidth = IMM_BOX_DEFAULT_WALL_WIDTH,
		insideEffect = None,
		noDownload = 0):
		
		return CImmBox.InitializeRect(self, device, rect, stiff, wallWidth,
			insideEffect, noDownload)


class pyImmEllipse(CImmEllipse):
	def ChangeParametersPoint(self,
		center,
		width = IMM_EFFECT_DONT_CHANGE,
		height = IMM_EFFECT_DONT_CHANGE,
		stiff = IMM_EFFECT_DONT_CHANGE,
		wallWidth = IMM_EFFECT_DONT_CHANGE,
		sat = IMM_EFFECT_DONT_CHANGE,
		stiffMask = IMM_EFFECT_DONT_CHANGE,
		clipMask = IMM_EFFECT_DONT_CHANGE,
		insideEffect = IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT,
		angle = IMM_EFFECT_DONT_CHANGE):
			
		return CImmEllipse.ChangeParametersPoint(self, center, width, height,
			stiff, wallWidth, sat, stiffMask, clipMask, insideEffect, angle)
	def ChangeParametersRect(self,
		rect,
		stiff = IMM_EFFECT_DONT_CHANGE,
		wallWidth = IMM_EFFECT_DONT_CHANGE,
		sat = IMM_EFFECT_DONT_CHANGE,
		stiffMask = IMM_EFFECT_DONT_CHANGE,
		clipMask = IMM_EFFECT_DONT_CHANGE,
		insideEffect = IMM_EFFECT_DONT_CHANGE_PCIMMEFFECT,  
		angle = IMM_EFFECT_DONT_CHANGE):
			
		return CImmEllipse.ChangeParametersRect(self, rect, stiff, wallWidth,
			sat, stiffMask, clipMask, insideEffect, angle)
				
				
	def InitializePoint(self, 
		device,
		center,
		width = IMM_ELLIPSE_DEFAULT_WIDTH,
		height = IMM_ELLIPSE_DEFAULT_HEIGHT,
		stiff = IMM_ELLIPSE_DEFAULT_STIFFNESS,
		wallWidth = IMM_ELLIPSE_DEFAULT_WALL_WIDTH,
		sat = IMM_ELLIPSE_DEFAULT_SATURATION,
		stiffMask = IMM_ELLIPSE_DEFAULT_STIFFNESS_MASK,
		clipMask = IMM_ELLIPSE_DEFAULT_CLIPPING_MASK,
		insideEffect = None,  
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
			
		return CImmEllipse.InitializePoint(self, device, width, height,
			stiff, wallWidth, sat, stiffMask, clipMask, center, insideEffect,
			angle, noDownload)
	def InitializeRect(self,
		device, 
		rect,
		stiff = IMM_ELLIPSE_DEFAULT_STIFFNESS,
		wallWidth = IMM_ELLIPSE_DEFAULT_WALL_WIDTH,
		sat = IMM_ELLIPSE_DEFAULT_SATURATION,
		stiffMask = IMM_ELLIPSE_DEFAULT_STIFFNESS_MASK,
		clipMask = IMM_ELLIPSE_DEFAULT_CLIPPING_MASK,
		insideEffect = None,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
			
		return CImmEllipse.InitializePoint(self, device, rect, stiff,
			wallWidth, sat, stiffMask, clipMask, insideEffect, angle, noDownload)


class pyImmDamper(CImmDamper):
	def ChangeParametersXY(self,
		vis = IMM_EFFECT_DONT_CHANGE,
        sat = IMM_EFFECT_DONT_CHANGE,
		minVel = IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE):
		
		return CImmDamper.ChangeParameters(self, vis, sat, minVel,
			dirX, dirY)
	def ChangeParametersPolar(self,
		vis = IMM_EFFECT_DONT_CHANGE,
		sat = IMM_EFFECT_DONT_CHANGE,
		minVel = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE):
		
		return CImmDamper.ChangeParametersPolar(self, vis, sat, minVel, angle)
	def InitializeXY(self,
		device,
		vis = IMM_DAMPER_DEFAULT_VISCOSITY,
		sat = IMM_DAMPER_DEFAULT_SATURATION,
		minVel = IMM_DAMPER_DEFAULT_MIN_VELOCITY,
		axis = IMM_EFFECT_AXIS_BOTH,
		dirX = IMM_EFFECT_DEFAULT_DIRECTION_X,
		dirY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
		noDownload = 0):
		
		return CImmDamper.Initialize(self, device, vis, sat, minVel,
			axis, dirX, dirY, noDownload)
	def InitializePolar(self,
		device,
		vis = IMM_DAMPER_DEFAULT_VISCOSITY,
		sat = IMM_DAMPER_DEFAULT_SATURATION,
		minVel = IMM_DAMPER_DEFAULT_MIN_VELOCITY,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
		
		return CImmDamper.InitializePolar(self, device, vis, sat, minVel,
			angle, noDownload)


class pyImmFriction(CImmFriction):
	def ChangeParametersXY(self,
		coeff = IMM_EFFECT_DONT_CHANGE,
		minVel= IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE):
		
		CImmFriction.ChangeParameters(self, coeff, minVel, dirX, dirY)
	def ChangeParametersPolar(self,
		coeff = IMM_EFFECT_DONT_CHANGE,
		minVel = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE):
		
		CImmFriction.ChangeParameters(self, coeff, minVel, angle)
		
	def InitializeXY(self,
		device,
		coeff = IMM_FRICTION_DEFAULT_COEFFICIENT,
		minVel = IMM_FRICTION_DEFAULT_MIN_VELOCITY,
		axis = IMM_EFFECT_AXIS_BOTH,
		dirX = IMM_EFFECT_DEFAULT_DIRECTION_X,
		dirY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
		noDownload = 0):
		
		CImmFriction.Initialize(self, device, coeff, minVel, axis,
			dirX, dirY, noDownload)
	def InitializePolar(self,
		device,
		coeff = IMM_FRICTION_DEFAULT_COEFFICIENT,
		minVel = IMM_FRICTION_DEFAULT_MIN_VELOCITY,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
		
		CImmFriction.Initialize(self, device, coeff, minVel, angle,
			noDownload)


class pyImmGrid(CImmGrid):
	def ChangeParameters(self,
		hSpacing = IMM_EFFECT_DONT_CHANGE,
		vSpacing = IMM_EFFECT_DONT_CHANGE,
		hNodeStrength = IMM_EFFECT_DONT_CHANGE,
		vNodeStrength = IMM_EFFECT_DONT_CHANGE,
		hOffset = IMM_EFFECT_DONT_CHANGE,
		vOffest = IMM_EFFECT_DONT_CHANGE,
		hNodeSat = IMM_EFFECT_DONT_CHANGE,
		vNodeSat = IMM_EFFECT_DONT_CHANGE):
		
		CImmGrid.ChangeParameters(self, hSpacing, vSpacing,
			hNodeStrength, vNodeStrength, hOffset, vOffset,
			hNodeSat, vNodeSat, noDownload)
	def Initialize(self,
		device,
		hSpacing = IMM_GRID_DEFAULT_HORIZ_SPACING,
		vSpacing = IMM_GRID_DEFAULT_VERT_SPACING,
		hNodeStrength = IMM_GRID_DEFAULT_NODE_STRENGTH,
		vNodeStrength = IMM_GRID_DEFAULT_NODE_STRENGTH,
		hOffset = IMM_GRID_DEFAULT_HORIZ_OFFSET,
		vOffset = IMM_GRID_DEFAULT_VERT_OFFSET,
		hNodeSat = IMM_GRID_DEFAULT_NODE_SATURATION,
		vNodeSat = IMM_GRID_DEFAULT_NODE_SATURATION,
		noDownload = 0):
	
		CImmGrid.Initialize(self, device, hSpacing, vSpacing,
			hNodeStrength, vNodeStrength, hOffset, vOffset,
			hNodeSat, vNodeSat, noDownload)


class pyImmInertia(CImmInertia):
	def ChangeParametersXY(self,
		coeff = IMM_EFFECT_DONT_CHANGE,
		sat = IMM_EFFECT_DONT_CHANGE,
		minAcc = IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE):
	
		CImmInertia.ChangeParameters(self, coeff, sat, minAcc,
			dirX, dirY)
	
	def ChangeParametersPolar(self,
		coeff = IMM_EFFECT_DONT_CHANGE,
		sat = IMM_EFFECT_DONT_CHANGE,
		minAcc = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE):
		
		CImmInertia.ChangeParametersPolar(self, coeff, sat, minAcc, angle)
			
	def InitializeXY(self,
		device,
		coeff = IMM_INERTIA_DEFAULT_COEFFICIENT,
		sat = IMM_INERTIA_DEFAULT_SATURATION,
		minAcc = IMM_INERTIA_DEFAULT_MIN_ACCELERATION,
		axis = IMM_EFFECT_AXIS_BOTH,
		dirX = IMM_EFFECT_DEFAULT_DIRECTION_X,
		dirY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
		noDownload = 0):
		
		CImmInertia.Initialize(self, device, coeff, sat, minAcc,
			axis, dirX, dirY, noDownload)
	def InitializePolar(self,
		device, 
		coeff = IMM_INERTIA_DEFAULT_COEFFICIENT,
		sat = IMM_INERTIA_DEFAULT_SATURATION,
		minAcc = IMM_INERTIA_DEFAULT_MIN_ACCELERATION,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
		
		CImmInertia.InitializePolar(self, device, coeff, sat,
			minAcc, angle, noDownload)


class pyImmSpring(CImmSpring):
	def ChangeParametersXY(self,
		center,
		stiff = IMM_EFFECT_DONT_CHANGE,
		sat = IMM_EFFECT_DONT_CHANGE,
		deadband = IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE):
	
		CImmSpring.ChangeParameters(self, center, stiff, sat,
			deadband, dirX, dirY)
	def ChangeParametersPolar(self,
		center,
		stiff = IMM_EFFECT_DONT_CHANGE,
		sat = IMM_EFFECT_DONT_CHANGE,
		deadband = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE):
		
		CImmSpring.ChangeParametersPolar(self, center, stiff,
			sat, deadband, angle)
		
	def InitializeXY(self,
		device,
		center,
		stiff = IMM_SPRING_DEFAULT_STIFFNESS,
		sat = IMM_SPRING_DEFAULT_SATURATION,
		deadband = IMM_SPRING_DEFAULT_DEADBAND,
		axis = IMM_EFFECT_AXIS_BOTH, 
		dirX = IMM_SPRING_DEFAULT_DIRECTION_X,
		dirY = IMM_SPRING_DEFAULT_DIRECTION_Y,
		useDeviceCoord = False,
		noDownload = 0):
		
		CImmSpring.Initialize(self, device, stiff, sat, deadband,
			axis, center, dirX, dirY, useDeviceCoord, noDownload)
	def InitializePolar(self,
		device, 
		center,
		stiff = IMM_SPRING_DEFAULT_STIFFNESS,
		sat = IMM_SPRING_DEFAULT_SATURATION,
		deadband = IMM_SPRING_DEFAULT_DEADBAND,
		useDeviceCoord = False,
		noDownload = 0):
		
		CImmSpring.InitializePolar(self, device, stiff, sat, deadband,
			center, useDeviceCoord, noDownload)


class pyImmTexture(CImmTexture):
	def ChangeTextureParams(self,
		posBumpMag = IMM_EFFECT_DONT_CHANGE,
		posBumpWidth = IMM_EFFECT_DONT_CHANGE,
		posBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		negBumpMag = IMM_EFFECT_DONT_CHANGE,
		negBumpWidth = IMM_EFFECT_DONT_CHANGE,
		negBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		offset = IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE):
		
		return CImmTexture.ChangeTextureParams(self, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, offset,
			dirX, dirY)
	def ChangeTextureParamsX(self,
		posBumpMag = IMM_EFFECT_DONT_CHANGE,
		posBumpWidth = IMM_EFFECT_DONT_CHANGE,
		posBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		negBumpMag = IMM_EFFECT_DONT_CHANGE,
		negBumpWidth = IMM_EFFECT_DONT_CHANGE,
		negBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		offset = IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE):
		return CImmTexture.ChangeTextureParamsX(self, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, offset,
			dirX, dirY)
	def ChangeTextureParamsY(self,
		posBumpMag = IMM_EFFECT_DONT_CHANGE,
		posBumpWidth = IMM_EFFECT_DONT_CHANGE,
		posBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		negBumpMag = IMM_EFFECT_DONT_CHANGE,
		negBumpWidth = IMM_EFFECT_DONT_CHANGE,
		negBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		offset = IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE):
		return CImmTexture.ChangeTextureParamsY(self, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, offset,
			dirX, dirY)
	def ChangeTextureParamsPolar(self,
		posBumpMag = IMM_EFFECT_DONT_CHANGE,
		posBumpWidth = IMM_EFFECT_DONT_CHANGE,
		posBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		negBumpMag = IMM_EFFECT_DONT_CHANGE,
		negBumpWidth = IMM_EFFECT_DONT_CHANGE,
		negBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		offset = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE):
		return CImmTexture.ChangeTextureParamsPolar(self, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, offset,
			angle)
	def ChangeTextureParamsPolarX(self,
		posBumpMag = IMM_EFFECT_DONT_CHANGE,
		posBumpWidth = IMM_EFFECT_DONT_CHANGE,
		posBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		negBumpMag = IMM_EFFECT_DONT_CHANGE,
		negBumpWidth = IMM_EFFECT_DONT_CHANGE,
		negBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		offset = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE):
		
		return CImmTexture.ChangeTextureParamsPolarX(self, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, offset,
			angle)
	def ChangeTextureParamsPolarY(self,
		posBumpMag = IMM_EFFECT_DONT_CHANGE,
		posBumpWidth = IMM_EFFECT_DONT_CHANGE,
		posBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		negBumpMag = IMM_EFFECT_DONT_CHANGE,
		negBumpWidth = IMM_EFFECT_DONT_CHANGE,
		negBumpSpacing = IMM_EFFECT_DONT_CHANGE,
		offset = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE):
		
		return CImmTexture.ChangeTextureParamsPolarY(self, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, offset,
			angle)
			
	def InitializeXY(self,
		device, 
		posBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
		posBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
		posBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
		negBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
		negBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
		negBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
		axis = IMM_EFFECT_AXIS_BOTH,
		offset = (0,0),
		dirX = IMM_EFFECT_DEFAULT_DIRECTION_X,
		dirY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
		noDownload = 0):
		
		return CImmTexture.InitTexture(self, device, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, axis,
			offset, dirX, dirY, noDownload)
	def InitializePolar(self,
		device,
		posBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
		posBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
		posBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
		negBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
		negBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
		negBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
		offset = (0,0),
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		noDownload = 0):
		
		return CImmTexture.InitTexturePolar(self, device, posBumpMag, posBumpWidth,
			posBumpSpacing, negBumpMag, negBumpWidth, negBumpSpacing, offset,
			angle, noDownload)


class pyImmPeriodic(CImmPeriodic):
	def ChangeParametersXY(self,
		mag = IMM_EFFECT_DONT_CHANGE,
		period = IMM_EFFECT_DONT_CHANGE,
		duration = IMM_EFFECT_DONT_CHANGE,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE,
		offset = IMM_EFFECT_DONT_CHANGE,
		phase = IMM_EFFECT_DONT_CHANGE,
		envelope = IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE):
		return CImmPeriodic.ChangeParameters(self, mag, period,
			duration, dirX, dirY, offset, phase, envelope)
		
	def ChangeParametersPolar(self,
		mag = IMM_EFFECT_DONT_CHANGE,
		period = IMM_EFFECT_DONT_CHANGE,
		duration = IMM_EFFECT_DONT_CHANGE,
		angle = IMM_EFFECT_DONT_CHANGE,
		phase = IMM_EFFECT_DONT_CHANGE,
		envelope = IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE):
		
		return CImmPeriodic.ChangeParametersPolar(self, mag, period,
			duration, angle, phase, envelope)
	def InitializeXY(self,
		device,
		mag = IMM_PERIODIC_DEFAULT_MAGNITUDE,
		period = IMM_PERIODIC_DEFAULT_PERIOD,
		duration = IMM_PERIODIC_DEFAULT_DURATION,
		dirX = IMM_PERIODIC_DEFAULT_DIRECTION_X,
		dirY = IMM_PERIODIC_DEFAULT_DIRECTION_Y,
		offset = IMM_PERIODIC_DEFAULT_OFFSET,
		phase = IMM_PERIODIC_DEFAULT_PHASE,
		envelope = None,
		noDownload = 0):
		
		return CImmPeriodic.Initialize(self, device, mag, period,
			duration, dirX, dirY, offset, phase, envelope, noDownload)
		
	def InitializePolar(self,
		device,
		mag = IMM_PERIODIC_DEFAULT_MAGNITUDE,
		period = IMM_PERIODIC_DEFAULT_PERIOD,
		duration = IMM_PERIODIC_DEFAULT_DURATION,
		angle = IMM_PERIODIC_DEFAULT_ANGLE,
		phase = IMM_PERIODIC_DEFAULT_PHASE,
		envelope = None,
		noDownload = 0):
		return CImmPeriodic.InitializePolar(self, device, mag, period,
			duration, angle, phase, envelope, noDownload)		


class pyImmRamp(CImmRamp):
	def ChangeParametersXY(self,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE,
		duration = IMM_EFFECT_DONT_CHANGE,
		magStart = IMM_EFFECT_DONT_CHANGE,
		magEnd = IMM_EFFECT_DONT_CHANGE,
		envelope = IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE):
		return CImmRamp.ChangeParameters(self, dirX, dirY, duration,
			magStart, magEnd, envelope)
		
	def ChangeParametersPolar(self,
		angle = IMM_EFFECT_DONT_CHANGE,
		duration = IMM_EFFECT_DONT_CHANGE,
		magStart = IMM_EFFECT_DONT_CHANGE,
		magEnd = IMM_EFFECT_DONT_CHANGE,
		envelope = IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE):
		
		return CImmRamp.ChangeParametersPolar(self, angle, duration,
			magStart, magEnd, envelope)
	
	def InitializeXY(self,
		device,
		dirX = IMM_EFFECT_DEFAULT_DIRECTION_X,
		dirY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
		duration = IMM_RAMP_DEFAULT_DURATION,
		magStart = IMM_RAMP_DEFAULT_MAGNITUDE_START,
		magEnd = IMM_RAMP_DEFAULT_MAGNITUDE_END,
		envelope = None,
		noDownload = 0):
		
		return CImmRamp.Initialize(self, device, dirX, dirY, duration,
			magStart, magEnd, envelope, noDownload)
	def InitializePolar(self,
		device,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		duration = IMM_RAMP_DEFAULT_DURATION,
		magStart = IMM_RAMP_DEFAULT_MAGNITUDE_START,
		magEnd = IMM_RAMP_DEFAULT_MAGNITUDE_END,
		envelope = None,
		flags = 0):
		
		return CImmRamp.InitializePolar(self, device, angle, duration,
			magStart, magEnd, envelope, noDownload)


class pyImmConstant(CImmConstant):
	def ChangeParametersXY(self,
		dirX = IMM_EFFECT_DONT_CHANGE,
		dirY = IMM_EFFECT_DONT_CHANGE,
		duration = IMM_EFFECT_DONT_CHANGE,
		mag = IMM_EFFECT_DONT_CHANGE,
		envelope = IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE):
		return CImmConstant.ChangeParameters(self, dirX, dirY, duration,
			mag, envelope)
		
	def ChangeParametersPolar(self,
		angle = IMM_EFFECT_DONT_CHANGE,
		duration = IMM_EFFECT_DONT_CHANGE,
		mag = IMM_EFFECT_DONT_CHANGE,
		envelope = IMM_EFFECT_DONT_CHANGE_PTR_ENVELOPE):
		return CImmConstant.ChangeParametersPolar(self, angle, duration,
			mag, envelope)
		
	def InitializeXY(self,
		device, 
		dirX = IMM_EFFECT_DEFAULT_DIRECTION_X,
		dirY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
		duration = IMM_CONSTANT_DEFAULT_DURATION,
		mag = IMM_CONSTANT_DEFAULT_MAGNITUDE,
		envelope = None,
		noDownload = 0):
		
		return CImmConstant.Initialize(self, device, dirX, dirY, duration,
			mag, envelope, noDownload)
	def InitializePolar(self,
		device,
		angle = IMM_EFFECT_DEFAULT_ANGLE,
		duration = IMM_CONSTANT_DEFAULT_DURATION,
		mag = IMM_CONSTANT_DEFAULT_MAGNITUDE,
		envelope = None,
		noDownload = 0):
		return CImmConstant.Initialize(self, device, angle, duration,
			mag, envelope, noDownload)


class pyImmSurface:
	def __init__(self, project):
		self.project = project
		self.effectPlaying = None
		self.regions = {}
	
	
	def RegisterRegion(self, regionID, regionHandler, effectName):
		self.regions[regionID] = (regionHandler, effectName)
	
	def UnregisterRegion(self, regionID):	
		del regions[regionID]
	
	
	
	
	
	def UpdateSurface(self, userParams):
		hit = 0
		for regionID in self.regions:
			handler = self.regions[regionID][0]
			effect = self.regions[regionID][1]
			hit = hit or handler.HitTestRegion(userParams, regionID)
			if hit:
				if not (self.effectPlaying == effect):
					if self.effectPlaying != None:
						self.project.Stop(self.effectPlaying)
					self.effectPlaying = effect
					self.project.Start(self.effectPlaying,IMM_EFFECT_DONT_CHANGE)
				return
		if not hit and not (self.effectPlaying == None):
			self.project.Stop(self.effectPlaying)
			self.effectPlaying = None
	
	
	def Stop(self):
		if not(self.effectPlaying == None):
			self.project.Stop(self.effectPlaying)
			self.effectPlaying = None



